/*

* 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 <uri8.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <sacls.h>

#include <apgtask.h> 

#include <centralrepository.h>

#include <AknUtils.h>

#include "hnengine.h"

#include "hnconvutils.h"

#include "hncontrollerinterface.h"

#include "hnfilter.h"

#include "hnsuitemodelcontainer.h"

#include "hnsuitemodel.h"

#include "hnserviceglobals.h"

#include "hnglobals.h"

#include "hnmdsuite.h"

#include "hnitemid.h"

#include "hnliwutils.h"

#include "hnrepositorymanager.h"

#include "menudebug.h"

#include "hnrepositorymanager.h"

#include "hnsuiteobserver.h"

#include "hnmdbasekey.h"

#include "hnitemsorder.h"

_LIT8(  KAnd8,                      "&" );

_LIT8(  KEquals8,                   "=" );

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

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

//

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

//

void CHnEngine::ConstructL()

    {

    iEEnv = CEikonEnv::Static();

    iSuiteContainer = CHnSuiteModelContainer::NewL( *this , iControllerInterface );

    iMetaDataModel = CHnMdModel::NewL( this, iSuiteContainer );

    iLight = CHWRMLight::NewL(this);

    iInstObserver = CHnInstallNotifier::NewL( this,

            KUidSystemCategory, KSAUidSoftwareInstallKeyValue  );

    }

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

//

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

//

EXPORT_C CHnEngine* CHnEngine::NewL( MHnControllerInterface& aController )

    {

    CHnEngine* self = CHnEngine::NewLC( aController );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

EXPORT_C CHnEngine* CHnEngine::NewLC( MHnControllerInterface& aController )

    {

    CHnEngine* self = new( ELeave ) CHnEngine( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

CHnEngine::CHnEngine( MHnControllerInterface& aController ):

    iControllerInterface( aController )

    {

    }

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

//

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

//

CHnEngine::~CHnEngine()

    {

    delete iInstObserver;

    delete iLight;

    if( iSuiteContainer )

        {

        iSuiteContainer->RemoveLiwObjects();

        }

    delete iMetaDataModel;

    delete iSuiteContainer;

    }

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

//

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

//

TInt CHnEngine::GetSuiteModelsCountL()

    {

    return iSuiteContainer->GetSuiteModelCount();

    }

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

//

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

//

TBool CHnEngine::SuiteModelLoadedL( TInt aId )

    {

    TBool ret( EFalse );

    TInt count( iSuiteContainer->GetSuiteModelCount() );

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

        {

        CHnSuiteModel* suite = iSuiteContainer->GetSuiteModel( i );

        if( suite->GetItemsOrder()->GetSuiteId() == aId )

            {

            ret = ETrue;

            break;

            }

        }

    return ret;

    }

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

//

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

//

CHnSuiteModel* CHnEngine::GetLastSuiteModelL()

    {

    return iSuiteContainer->GetLastSuiteModel(); 

    }

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

//

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

//

CHnSuiteModel* CHnEngine::GetParentSuiteModelL()

    {

    return iSuiteContainer->GetParentSuiteModel(); 

    }

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

//

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

//

EXPORT_C TInt CHnEngine::TriggerHnEventL( const TInt aHnEventId, 

        const TInt aRecipientId, CLiwGenericParamList* aEventParameters )

    {

    TInt ret = iSuiteContainer->OfferHnEventL( aHnEventId, aRecipientId,

            aEventParameters);

    return ret;

    }

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

//

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

//

void CHnEngine::HighlightPlacementFromUriL( const TDesC8& aUriFragment )

    {

    TLex8 lexFrag( aUriFragment );

    TInt highLight( 0 );

    if( !( lexFrag.Val( highLight ) ) )

        {

        iSuiteContainer->GetLastSuiteModel()->SetSuiteHighlightL( highLight );

        iControllerInterface.HandleSuiteEventL( ESuiteHighlightChanged,

                iSuiteContainer->GetLastSuiteModel() );

        }

    }

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

//

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

//

TInt CHnEngine::LoadSuiteFromUriL( const TDesC8& aSuiteName,  

        const TDesC8& aUriQuery, const TDesC8& aUriFragment )

    {

    TInt error( KErrNone );

    if( !( aSuiteName.Compare( KRoot8 ) ) )

        {

        CLiwGenericParamList* uriParams = 

			UriQueryToLiwListLC( aUriQuery, aUriFragment, aSuiteName );

        CLiwGenericParamList* params = CLiwGenericParamList::NewLC();

        params->AppendL( iMetaDataModel->GetSuiteParameters( 0 ) );

        params->AppendL( *uriParams );

        ResetModelsL();

        iMetaDataModel->QueueForeground( CHnMdModel::EWhenAnySuiteIsEvaluated );

        error = InitializeL( *params );

        CleanupStack::PopAndDestroy( params );

        CleanupStack::PopAndDestroy( uriParams );

        }

    else

        {

        CLiwGenericParamList* params =

			UriQueryToLiwListLC( aUriQuery, aUriFragment, aSuiteName );

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

        params->AppendL( TLiwGenericParam( KNewSuiteParamNameEn, 

            TLiwVariant( *suiteName ) ) );

        error = HandleNewSuiteLoadedEventL( *params );

        CleanupStack::PopAndDestroy( suiteName );

        CleanupStack::PopAndDestroy( params );

        }

    return error;

    }

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

//

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

//

TBool CHnEngine::SuitesAreTheSameL( const TDesC& aLastSuiteName,

    const TDesC8& aFirstSuiteName )

    {

    RBuf8 lastSuiteName;

    CleanupClosePushL( lastSuiteName );

    lastSuiteName.CreateL( aLastSuiteName.Length() );

    lastSuiteName.Copy( aLastSuiteName );

    TBool suitesAreTheSame( !lastSuiteName.Compare( aFirstSuiteName ) );

    CleanupStack::PopAndDestroy( &lastSuiteName );

    return suitesAreTheSame;

    }

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

//

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

//

void CHnEngine::HandleTheSameSuitesL( TBool aNextExists, const TDesC8& aParams )

    {

    RBuf exitMode;

    CleanupClosePushL( exitMode );

    CLiwGenericParamList* params = UriQueryToLiwListLC( aParams, KNullDesC8, KNullDesC8 );

    HnLiwUtils::GetStringL( *params, KExitModeParams, exitMode );

    if ( !exitMode.Compare( KExitModeHide ) )

        {

        // set parameters

        iSuiteContainer->GetLastSuiteModel()->SetExitMode( EExitModeHide );

        }

    CleanupStack::PopAndDestroy( params );

    CleanupStack::PopAndDestroy( &exitMode );

    if ( !aNextExists )

        {

        // refresh if necessary

        iControllerInterface.NotifyUiRefreshL( ERefreshSuite );

        }

    }

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

//

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

//

EXPORT_C void CHnEngine::LoadSuitesFromUriL( const TDesC8& aUri )

	{

	DEBUG(("_MM_:CHnEngine::LoadSuitesFromUriL IN"));

	DEBUG8(("_MM_:\tURI: %S",&aUri));

	TBool consumed(EFalse);

    if ( aUri.Find( KSetFocusWithPref ) != KErrNotFound )

	    {

	    LoadFromCrL( aUri );

	    consumed = ETrue;

	    }

    if ( !consumed )

    	{

    	consumed = HandleActionL( aUri );

    	}

    if ( !consumed )

    	{

    	LoadSuitesL( aUri );

    	}

    DEBUG(("_MM_:CHnEngine::LoadSuitesFromUriL OUT"));

    }

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

//

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

//

TInt CHnEngine::HandleModelEventL( const TDesC& aEventName,

                                CLiwGenericParamList& aParams )

    {

    TInt ret(KErrNotFound);

    if ( aEventName == KNewSuiteLoadedMdEvent )

        {

        // This handles new suite creation, putting its visual model 

        // onto the stack eventually.

        ret = HandleNewSuiteLoadedEventL( aParams );

        }

    else if ( aEventName == KBackMdEvent )

        {

        const TDesC& suiteName = iSuiteContainer->GetLastSuiteModel()->SuiteName();

        ret = HandleBackEventL( suiteName );

        }

    else if (aEventName == KReevaluateMdEvent )

        {

        // This event triggers reevaluate on the model.

        // aParams holds liw packed filter.

        ret = HandleReevaluateEventL( aParams );

        }

    else if (aEventName == KSwitchWidgetMdEvent )

        {

        // Widget change is requested.

        ret = HandleWidgetChangeL( aParams );

        }

    else if (aEventName == KRefreshUiMdEvent )

        {

        // Refresh of the whole of the UI is refreshed

        iControllerInterface.NotifyUiRefreshL( ERefreshSuite );

        ret = KErrNone;

        }

    else if (aEventName == KRefreshToolbarMdEvent )

        {

        // Just the toolbar in UI is refreshed

        iControllerInterface.NotifyUiRefreshL( ERefreshToolbar );

        ret = KErrNone;

        }

    else if (aEventName == KStartEditModeMdEvent )

        {

        // Starting edit mode

        iControllerInterface.NotifyUiRefreshL( EStartEditMode );

        ret = KErrNone;

        }

    else if (aEventName == KStopEditModeMdEvent )

        {

        // Stopping edit mode

        iControllerInterface.NotifyUiRefreshL( EStopEditMode );

        ret = KErrNone;

        }    

    else if (aEventName == KSetFocusEvent )

        {

        // SetFocus

        ret = HandleSetFocusEventL( aParams );

        }

    else if (aEventName == KZoomLarge )

        {

        // Stopping edit mode

        iControllerInterface.NotifyUiRefreshL( EZoomLarge );

        ret = KErrNone;

        }

    else if (aEventName == KZoomSmall)

		{

		// Stopping edit mode

		iControllerInterface.NotifyUiRefreshL( EZoomSmall );

		ret = KErrNone;

		}

    else if (aEventName == KZoomNormal )

        {

        // Stopping edit mode

        iControllerInterface.NotifyUiRefreshL( EZoomNormal );

        ret = KErrNone;

        }   

    else if (aEventName == KAppGainForeground )

    	{

    	//force matrix gain foreground

        DEBUG(("_MM_:CHnEngine::HandleModelEventL EForegroundGain"));

        iControllerInterface.NotifyUiRefreshL( EForegroundGain );

        ret = KErrNone;

    	}

    else if (aEventName == KAppGainBackground )

    	{

    	//force matrix gain background

        DEBUG(("_MM_:CHnEngine::HandleModelEventL EBackgroundGain"));

        iControllerInterface.NotifyUiRefreshL( EBackgroundGain );

        ret = KErrNone;

    	}

    return ret;

    }

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

//

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

//

TInt CHnEngine::HandleWidgetChangeL( 

        CLiwGenericParamList& aParams )

    {

    THnSuiteWidgetType type = EChangeWidget;   

    TInt pos( 0 );

    const TLiwGenericParam* param = NULL;

    param = aParams.FindFirst( pos,  KWidgetTypeAttrName8 );

    if ( pos != KErrNotFound )

        {

        TPtrC widgetType( KNullDesC );

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

        if ( widgetType.Compare( KWidgetTypeList ) == 0 )

            type = EListWidget; 

        else if ( widgetType.Compare( KWidgetTypeGrid ) == 0 ) 

            type = EGridWidget; 

        else if ( widgetType.Compare( KWidgetTypeCoverFlow ) == 0 )

            type = ECoverFlowWidget;  

        }

    CHnSuiteModel* model  = iSuiteContainer->GetLastSuiteModel();

    return HandleWidgetChangeL( model->SuiteName(), type );

    }

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

//

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

//

TInt CHnEngine::HandleWidgetChangeL( const TDesC& aSuiteName,

        THnSuiteWidgetType aType )

    {   

    DEBUG(("_MM_:CMatrixMenuAppUi::HandleWidgetChangeL IN"));

    TInt ret( KErrGeneral );

    CHnRepositoryManager* rep = CHnRepositoryManager::NewLC();

    THnSuiteWidgetType type( EUnspecified );

    TInt err( rep->ReadSuiteWidgetTypeL( aSuiteName, type ) );

    if( ( !err || err == KErrNotFound ) && type != EUnspecified )

        {  

        ret = rep->StoreSuiteWidgetTypeL( aSuiteName, aType );

        }

    CleanupStack::PopAndDestroy( rep );

    DEBUG(("_MM_:CMatrixMenuAppUi::HandleWidgetChangeL OUT"));

    return ret;

    }

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

//

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

//

TInt CHnEngine::HandleReevaluateEventL( 

        CLiwGenericParamList& aParams )

    {

    TInt ret(KErrNone);

    // Paths to retrieve filter values

    _LIT8( KGenreGlobalPath, "filter:genre");

    _LIT8( KIdGlobalPath, "filter:id");

    _LIT8( KGenrePath, "filter:[%d]/genre");

    _LIT8( KItemPath, "filter:[%d]/item");

    CHnFilter* filter = CHnFilter::NewLC();

    TLiwGenericParam param;

    param.PushL();

    aParams.AtL(0, param);

    ASSERT( !param.Name().Compare( KFilterElementItem8 ) );

    TLiwVariant suiteIdVariant;

    suiteIdVariant.PushL();

    TLiwVariant genreVariant;

    genreVariant.PushL();

    TInt idFound = 

        HnLiwUtils::GetVariantL( aParams, KIdGlobalPath(), suiteIdVariant );

    TInt found = 

        HnLiwUtils::GetVariantL(aParams, KGenreGlobalPath(), genreVariant );

    if (idFound != KErrNotFound)

        {

        filter->SetSuiteId( suiteIdVariant.AsTInt32() );

        filter->SetEvaluateSuiteL( ETrue );

        }

    else if (found != KErrNotFound && found != KErrBadDescriptor)

        {

        filter->SetSuiteNameL( genreVariant.AsDes() );

        filter->SetEvaluateSuiteL( ETrue );

        }

    else

        {

        filter->SetEvaluateSuiteL( EFalse );

        // For each entry in the fitler list....

        for ( int i=0; i< param.Value().AsList()->Count(); i++ )

            {

            RBuf8 path;

            CleanupClosePushL( path );

            path.CreateL( KGenrePath().Length() );

            path.Format( KGenrePath, i );

            TLiwVariant genreVariant;

            HnLiwUtils::GetVariantL(aParams, path, genreVariant );

            path.Close();

            path.CreateL( KItemPath().Length() );

            path.Format( KItemPath, i );

            TLiwVariant itemVariant;

            HnLiwUtils::GetVariantL(aParams, path, itemVariant );

            CleanupStack::PopAndDestroy( &path );

            TPtrC suiteName;

            TPtrC itemId;

            genreVariant.Get(suiteName);

            itemVariant.Get(itemId);

            CHnItemId* itemIdObject = CHnItemId::NewLC(suiteName, itemId);

            filter->AppendItemIdL( itemIdObject );

            CleanupStack::Pop( itemIdObject );

            genreVariant.Reset();

            itemVariant.Reset();

            }

        }

    CleanupStack::PopAndDestroy( &genreVariant );

    CleanupStack::PopAndDestroy( &suiteIdVariant );

    CleanupStack::PopAndDestroy( &param );

    iMetaDataModel->EvaluateL( *filter );

    CleanupStack::PopAndDestroy( filter );

    return ret;

    }

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

//

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

//

TInt CHnEngine::HandleBackEventL( const TDesC& aGenre, TInt aIterations )

    {