/*

* 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:

*

*/

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <AvkonInternalCRKeys.h>

#include "hnmdmodel.h"

#include "hnmdsuite.h"

#include "hnrepositoryobserver.h"

#include "hnfilter.h"

#include "hnglobals.h"

#include "hneventhandler.h"

#include "hnmdlocalization.h"

#include "hnxmlmodelprovider.h"

#include "hnsuitemodelcontainer.h"

#include "hnitemsorder.h"

#include "hninterface.h"

#include "menudebug.h"

#include "hnconvutils.h"

#include "hnbitmapidcache.h"

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

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

//

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

//

void CHnMdModel::ConstructL( MHnMdModelEventObserver *aModelObserver,

        CHnSuiteModelContainer * aSuiteModelContainer )

    {

    MMPERF(("CHnMetaDataModel::ConstructL - START"));

    MMPERF(("CHnMetaDataModel::ConstructL - query handler ready"));

    iLocalization = CHnMdLocalization::NewL();

    MMPERF(("CHnMetaDataModel::ConstructL - localization ready"));

    iXmlModelProvider = CHnXmlModelProvider::NewL();

    MMPERF(("CHnMetaDataModel::ConstructL - bitmap and mask ids cache ready"));

    iBitmapIdCache = CHnBitmapIdCache::NewL();

    MMPERF(("CHnMetaDataModel::ConstructL - model privider ready"));

    iXmlModelProvider->ReloadModelL();

    MMPERF(("CHnMetaDataModel::ConstructL - model reloaded"));

    iCmnPtrs.iLocalization = iLocalization;

    iCmnPtrs.iIdGenerator = &iIdGenerator;

    iCmnPtrs.iModel = this;

    iCmnPtrs.iXmlModelProvider = iXmlModelProvider;

    iCmnPtrs.iContainer = aSuiteModelContainer;

    iCmnPtrs.iModelEventObserver = aModelObserver;

    iCmnPtrs.iBitmapIdCache = iBitmapIdCache;

    THnMdCommonPointers::SetStatic(&iCmnPtrs);

    iMode = EMdModeNormal;

    iRepositoryWidgetTypeObserver = CHnRepositoryWidgetTypeObserver::NewL( &iCmnPtrs, KMatrixRepositoryUid );

    iRepositoryShowFolderObserver = CHnRepositoryShowFolderObserver::NewL( &iCmnPtrs, KCRUidMenu, KMenuShowFolder );

    MMPERF(("CHnMetaDataModel::ConstructL - rep. observer ready"));

    }

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

//

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

//

EXPORT_C CHnMdModel* CHnMdModel::NewL(

        MHnMdModelEventObserver* aModelObserver,

        CHnSuiteModelContainer * aSuiteModelContainer  )

    {

    CHnMdModel* self = CHnMdModel::NewLC( aModelObserver,

            aSuiteModelContainer );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

EXPORT_C CHnMdModel* CHnMdModel::NewLC(

        MHnMdModelEventObserver* aModelObserver,

        CHnSuiteModelContainer * aSuiteModelContainer )

    {

    CHnMdModel* self = new( ELeave ) CHnMdModel();

    CleanupStack::PushL( self );

    self->ConstructL( aModelObserver, aSuiteModelContainer );

    return self;

    }

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

//

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

//

CHnMdModel::CHnMdModel()

    {

    }

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

//

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

//

CHnMdModel::~CHnMdModel()

    {

    delete iRepositoryWidgetTypeObserver;

    delete iRepositoryShowFolderObserver;

    iLoadedSuites.ResetAndDestroy();

    delete iXmlModelProvider;

    delete iLocalization;

    delete iBitmapIdCache;

    }

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

//

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

//

EXPORT_C TInt CHnMdModel::HandleBackEventL(

        CHnSuiteModelContainer* aMulContainer,

        const TDesC& aSuiteName,

        TInt aIterations )

    {

    TInt ret( KErrNotFound );

#ifdef _DEBUG

    // check if genres match

    CHnMdSuite* lastMdModel = GetLastSuite();

    ASSERT( !lastMdModel->SuiteName().Compare( aSuiteName ) );

#endif

    TInt countDown( aIterations );

    CHnSuiteModel* current = NULL;

    while( ( current = aMulContainer->GetParentSuiteModel() ) != NULL &&

            countDown > 0 )

        {

        current = aMulContainer->GetLastSuiteModel();

        // pop the suite model

        aMulContainer->PopSuiteModelL( current->SuiteName() );

        // remove the suite that we are leaving

        DeleteLastSuite();

        countDown--;

        }

    current = aMulContainer->GetLastSuiteModel();

    current->GetItemsOrder()->MarkSuiteUninitialized();

    CHnFilter* filter = CHnFilter::NewLC();

    filter->SetSuiteNameL( current->SuiteName() );

    filter->SetSuiteId( current->CustomId() );

    GetLastSuite()->MarkEvaluationL( *filter, *current);

    CleanupStack::PopAndDestroy( filter );

    //Evaluate suite at the top (if needed)

    EvaluateTopSuiteL();

    return ret;

    }

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

//

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

//

EXPORT_C void CHnMdModel::HandleSisInstallationEventL(

        CHnSuiteModelContainer* /*aModelContainer*/ )

    {

    iXmlModelProvider->ReloadModelL();

    }

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

//

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

//

void CHnMdModel::ReloadStackSuitesL( CHnSuiteModelContainer* aModelContainer )

	{

    RPointerArray< CLiwGenericParamList > paramsArray;

    CleanupResetAndDestroyPushL( paramsArray );

    TBool rootDisplayed( iLoadedSuites.Count() == 1 );

    while( iLoadedSuites.Count() > 0 )

        {

        // break loop to leave root suite on the stack

        if( ( iLoadedSuites.Count() == 1 && paramsArray.Count() > 0 )

                || rootDisplayed )

            {

            break;

            }

        CHnMdSuite* suite = GetLastSuite();

        if( iXmlModelProvider->SuiteExistsL( suite->SuiteName() ) )

            {

            CLiwGenericParamList* suiteParams = CLiwGenericParamList::NewL();

            CleanupStack::PushL( suiteParams );

            suiteParams->AppendL( suite->GetSuiteParameters() );

            paramsArray.Append( suiteParams );

            CleanupStack::Pop( suiteParams );

            }

        aModelContainer->PopSuiteModelL( suite->SuiteName() );

        DeleteLastSuite();

        }

    TInt err( KErrNone );

    CHnFilter* filter = CHnFilter::NewLC();

    filter->SetEvaluateSuiteL( ETrue );

    SetModeL( iMode );

    for( TInt i( paramsArray.Count() - 1 ); i >= 0 && !err; i-- )

        {

        CLiwGenericParamList* suiteParams = CLiwGenericParamList::NewL();

        CleanupStack::PushL(suiteParams);

        suiteParams->AppendL( *(paramsArray[ i ]));

        TInt pos( 0 );

        const TLiwGenericParam* param = suiteParams->FindFirst( pos, KSuiteName8 );

        if ( param && pos >= 0)

            {

            TPtrC suiteName;

            param->Value().Get( suiteName );

            err = LoadSuiteL( suiteName, suiteParams );

            }

        CleanupStack::PopAndDestroy( suiteParams );

        GetLastSuite()->SetModeL( iMode );

        GetLastSuite()->MarkEvaluationL(

                *filter, *iCmnPtrs.iContainer->GetLastSuiteModel() );

        GetLastSuite()->EvaluateL( *iCmnPtrs.iContainer->GetLastSuiteModel() );

        }

    CleanupStack::PopAndDestroy( filter );

    CleanupStack::PopAndDestroy( &paramsArray );

	}

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

//

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

//

EXPORT_C void CHnMdModel::DeleteLastSuite()

    {

    CHnMdSuite* tmpPtr = GetLastSuite();

    iLoadedSuites.Remove( iLoadedSuites.Count() - 1 );

    delete tmpPtr;

    }

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

//

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

//

EXPORT_C void CHnMdModel::ReleaseLocalization()

    {

    iLocalization->ReleaseResourceFiles();

    iXmlModelProvider->ResetCache();

    }

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

//

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

//

EXPORT_C void CHnMdModel::ReloadLocalizationL()

    {

    iLocalization->ReloadResourceFilesL();

    }

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

//

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

//

EXPORT_C void CHnMdModel::EvaluateL()

    {

    CHnFilter* empty = CHnFilter::NewLC();

    EvaluateL( *empty );

    CleanupStack::PopAndDestroy( empty );

    }

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

//

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

//

EXPORT_C void CHnMdModel::SetModeL( TMdMode aMode )

    {

    iMode = aMode;

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

        {

        CHnMdSuite* suite = iLoadedSuites[i];

        ASSERT( suite != NULL );

        suite->SetModeL( aMode );

        }

    }

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

//

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

//

EXPORT_C CHnMdSuite* CHnMdModel::GetLastSuite()

    {

    return (iLoadedSuites.Count()>0)

            ? iLoadedSuites[ iLoadedSuites.Count()-1 ]

            : NULL;

    }

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

//

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

//

EXPORT_C void CHnMdModel::IgnoreEvaluations( TBool aIgnore )

    {

    iIgnoreEvaluations = aIgnore;

    }

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

//

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

//

EXPORT_C void CHnMdModel::QueueForeground(

        TForegroundGainTriggeringEvent aWhen )

    {

    switch ( aWhen )

        {

        case EWhenAnySuiteIsEvaluated:

            iForegroundQueued = ETrue;

            iForegroundTriggeringSuite = NULL;

            break;

        case EWhenCurrentTopSuiteIsEvaluated:

            iForegroundQueued = ETrue;

            iForegroundTriggeringSuite = iCmnPtrs.iContainer->GetLastSuiteModel();

            break;

        case ENever:

            iForegroundQueued = EFalse;

            iForegroundTriggeringSuite = NULL;

            break;

        default:

            ASSERT( 0 );

        }

    }

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

//

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

//

EXPORT_C TBool CHnMdModel::IsForegroundQueued() const

	{

	return iForegroundQueued;

	}

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

//

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

//

void CHnMdModel::SuiteModelReadyToShowL( CHnSuiteModel* aJustEvaluatedSuite )

    {

    if ( !aJustEvaluatedSuite )

        {

        User::Leave( KErrArgument );

        }

    if ( IsForegroundQueued() && ( !iForegroundTriggeringSuite ||

            iForegroundTriggeringSuite == aJustEvaluatedSuite ) )

    	{

    	CLiwGenericParamList* pl = CLiwGenericParamList::NewL();

    	CleanupStack::PushL( pl );

    	iCmnPtrs.iModelEventObserver->HandleModelEventL( KAppGainForeground, *pl );

    	CleanupStack::PopAndDestroy( pl );

    	QueueForeground( ENever );

    	}

    }

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

//

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

//

CHnMdSuite* CHnMdModel::GetSuite( TInt aPosition )

    {

    return ( (aPosition >= 0) && (aPosition < iLoadedSuites.Count()) )

            ? iLoadedSuites[ aPosition ]

            : NULL;

    }

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

//

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

//

EXPORT_C CLiwGenericParamList& CHnMdModel::GetSuiteParameters( TInt aPosition )

    {

    return GetSuite( aPosition )->GetSuiteParameters();

    }

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

//

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

//

EXPORT_C void CHnMdModel::EvaluateL( CHnFilter& aFilter )

    {

    for ( TInt i = iLoadedSuites.Count() - 1; i >= 0; i-- )

        {

        iLoadedSuites[i]->MarkEvaluationL( aFilter, *iCmnPtrs.iContainer->GetSuiteModel(i) );

        if( i == iLoadedSuites.Count() - 1 && !iIgnoreEvaluations )

            {

            iLoadedSuites[i]->EvaluateL( *iCmnPtrs.iContainer->GetSuiteModel(i) );

            }

        }

    }

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

//

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

//

EXPORT_C TInt CHnMdModel::LoadSuiteL( const TDesC& aGenre,

        CLiwGenericParamList* aSuiteParams )

    {

    TInt err( KErrNone );

	RXmlEngDocument xmlDoc;

	// Xml model provider takes ownership of xmlDoc.

	TRAP( err, iXmlModelProvider->GetModelL( aGenre, xmlDoc ) );

	TXmlEngElement element;

    if ( !err )

        {

        element = xmlDoc.DocumentElement().AsElement();

        if ( element.Name() != KContentElementName8 )

            {

            err = KErrCorrupt;

            }

        }

    if ( !err )

        {

        CHnMdSuite* newSuite = CHnMdSuite::NewLC( element, &iCmnPtrs );

        if (aSuiteParams)

            {

            newSuite->SetSuiteParametersL( *aSuiteParams );

            }

        TInt pos( 0 );

        newSuite->GetSuiteParameters().FindFirst( pos, KSuiteName8);

        if ( pos == KErrNotFound )

        	{

        	newSuite->GetSuiteParameters().AppendL(

        			TLiwGenericParam(KSuiteName8, TLiwVariant( aGenre ) ) );

        	}

        iCmnPtrs.iContainer->PushNewSuiteModelL( newSuite->SuiteName() );

        iCmnPtrs.iContainer->GetLastSuiteModel()->GetItemsOrder()->

            SetSuiteId( iCmnPtrs.iIdGenerator->GetNextId() );

        CleanupStack::Pop( newSuite );

        iLoadedSuites.AppendL( newSuite );

        }

    else

    	{

    	MMPERF(("CHnMdModel::LoadSuiteL - Error TRAPPED!"));

    	}

    return err;

    }

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

//

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

//

EXPORT_C TBool CHnMdModel::SuiteModelExistsL( const TDesC8& aSuiteModel )

    {

    TBool res( EFalse );

    HBufC* suiteName = HnConvUtils::Str8ToStrLC( aSuiteModel );

    res = iXmlModelProvider->SuiteExistsL( *suiteName ) ||

            aSuiteModel.Compare( KRoot8 ) == KErrNone ;

    CleanupStack::PopAndDestroy( suiteName );

    return res;

    }

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

//

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

//

EXPORT_C void CHnMdModel::GetCurrentUriL( TDes& aUri )

    {

    iXmlModelProvider->ReloadModelL();

    aUri.Append( KPrefMm );

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

        {

        aUri.Append( iLoadedSuites[ i ]->SuiteName() );

        aUri.Append( KSlash );

        }

    }

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

//

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

//

void CHnMdModel::EvaluateTopSuiteL()

    {

    if ( !iIgnoreEvaluations )

        {

        TInt topItem = iLoadedSuites.Count() - 1;

        iLoadedSuites[topItem]->EvaluateL( *iCmnPtrs.iContainer->GetSuiteModel(topItem) );

        }

    }

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

//

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

//

TInt CHnMdModel::LoadedSuitesCount()

	{

	return iLoadedSuites.Count();

	}