/*

* 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 "hnmdsuite.h"

#include "hnmditem.h"

#include "hnmdmodel.h"

#include "hnstringhandler.h"

#include "hnsuitemodelcontainer.h"

#include "hnitemsorder.h"

#include "hnconvutils.h"

#include "hnliwutils.h"

#include "hnutils.h"

#include "hnfilter.h"

#include "menudebug.h"

#include "hnactionmodel.h"

#include "hnmdaction.h"

#include "hnmdservicecommand.h"

#include "hnmdlocalization.h"

#include "hnmdqueries.h"

#include "hnmdquery.h"

#include "hnrepositorymanager.h"

#include "hnmdbasekey.h"

#include "hninterface.h"

#include "hnservicehandler.h"

#include "hnmdeventmapping.h"

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

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

//

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

//    

EXPORT_C CLiwGenericParamList& CHnMdSuite::GetSuiteParameters()

    {

    return *iSuiteParams;

    }

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

//

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

//

EXPORT_C void CHnMdSuite::SetSuiteParametersL(CLiwGenericParamList& aParams)

    {

    iSuiteParams->Reset();

    iSuiteParams->AppendL( aParams );               

    }

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

//

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

//

void CHnMdSuite::ConstructL( TXmlEngElement aElement )

    {

    DEBUG(("_MM_: CHnMdSuite::ConstructL IN"));

    // append localization elements

    iCmnPtrs->iLocalization->AppendLocalizationsL( aElement );

    RXmlEngNodeList<TXmlEngElement> elements;

    CleanupClosePushL( elements );

    aElement.GetChildElements( elements );

    // suite element was found

    TBool suiteFound( EFalse );

    // one suite per file

    TXmlEngElement suiteElement;

    while ( elements.HasNext() )

        {

        suiteElement = elements.Next();

        if ( !suiteElement.Name().Compare( KSuiteElementName8 ) )

            {

            suiteFound = ETrue;

            break;

            }

        }

    if ( suiteFound )

        {

        // set event mapping

        iEventMapping = CHnMdEventMapping::NewL( suiteElement, iCmnPtrs );

        // set genre

        SetGenreL( suiteElement.AttributeNodeL( KGenreAttrName8 ) );

        // set widget type

        // widget needs to be set before template will be set

        SetWidgetTypeL( suiteElement.AttributeNodeL( KWidgetTypeAttrName8 ) );

        // set template

        SetTemplateL( suiteElement.AttributeNodeL( KTemplateAttrName8 ) );

        // set name

        SetTitleL( suiteElement.AttributeNodeL( KTitleAttrName8 ) );

        // set empty text

        SetEmptyTextL( suiteElement.AttributeNodeL( KEmptyTextAttrName8 ) );

        // set custom identifier

        SetCustomIdL( suiteElement );

        // set entries

        CreateItemsL( suiteElement, iCmnPtrs );

        // set queries

        iQueries = CHnMdQueries::NewL( suiteElement );

        // set cached parameters

        iSuiteParams = CLiwGenericParamList::NewL();

        }

    else

        {

        // definiotion of the suite was not found!

        DEBUG(("_MM_: CHnMdSuite::ConstructL Suite definition not found!"));

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( &elements );

    DEBUG(("_MM_: CHnMdSuite::ConstructL OUT"));

    }

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

//

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

//

CHnMdSuite* CHnMdSuite::NewL(TXmlEngElement aElement,

                                            THnMdCommonPointers* aCmnPtrs)

    {

    CHnMdSuite* self = CHnMdSuite::NewLC( aElement, aCmnPtrs );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CHnMdSuite* CHnMdSuite::NewLC(TXmlEngElement aElement,

                                            THnMdCommonPointers* aCmnPtrs)

    {

    CHnMdSuite* self = new( ELeave ) CHnMdSuite( aCmnPtrs );

    CleanupStack::PushL( self );

    self->ConstructL( aElement );

    return self;

    }

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

//

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

//

CHnMdSuite::CHnMdSuite( THnMdCommonPointers* aCmnPtrs )

    : iCmnPtrs( aCmnPtrs ), iAllowableTemplate(NULL)

    {

    }

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

//

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

//

CHnMdSuite::~CHnMdSuite()

    {

    iAllowableWidgetType.Close();

    delete iAllowableTemplate;

    delete iEventMapping;

    iSuiteName.Close();

    iItems.ResetAndDestroy();

    iTemplate.Close();

    iTitle.Close();

    iEmptyText.Close();

    iCustomId8.Close();

    delete iQueries;

    delete iSuiteParams;

    iAllowedTypes.Close();

    delete iQc;

    }

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

//

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

//

TInt CHnMdSuite::EvaluateL( CHnSuiteModel & aSuiteModel )

    {

    MMPERF(("CHnMdSuite::EvaluateL - START"));

    aSuiteModel.GetItemsOrder()->DefineModelItemCountL( iItems.Count() );

    if( iEvaluationNeeded )

        {

        EvaluateSuiteItselfL( aSuiteModel );

        MMPERF(("CHnMdSuite::EvaluateL - suite evaluated"));

        iEvaluationNeeded = EFalse;

        }

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

    	{

    	CHnMdItem * item = iItems[i];

    	item->SetAlternativeTemplateL( GetAlternativeWidgetNumber() );

    	item->EvaluateItemL( aSuiteModel, GetSuiteParameters(), i );

    	}

    MMPERF(("CHnMdSuite::EvaluateL - items evaluated - DONE"));

    return KErrNone;

    }

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

//

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

//

void CHnMdSuite::MarkEvaluationL( CHnFilter& aFilter, CHnSuiteModel& aSuiteModel )

    {  

    if (aFilter.HasSuiteId())

        {

        if (aSuiteModel.CustomId() == aFilter.SuiteId() )

            {

            if ( aFilter.IsEvaluateSuite() )

                {

                iEvaluationNeeded = ETrue;

                }

            for (TInt item(0); item < iItems.Count(); item++)

               {

               iItems[item]->MarkEvaluationL( aFilter );

               }

            }

        else

            {

            for (TInt itemIter(0); itemIter < iItems.Count(); itemIter++)

                {

                RArray< TInt > ids;

                CleanupClosePushL( ids );

                aSuiteModel.GetItemsOrder()->GetIdsForL( itemIter, ids);

                for (TInt idsIter(0); idsIter < ids.Count(); idsIter++)

                    {

                    if (aFilter.SuiteId() == ids[idsIter])

                        {

                        iItems[itemIter]->MarkEvaluationL( aFilter );

                        if (aFilter.IsEvaluateSuite())

                            {

                            iEvaluationNeeded = ETrue;

                            }

                        }

                    }                        

                CleanupStack::PopAndDestroy( &ids );

                }

            }

        }

    else if( aFilter.HasSuiteName() )

        {

        if( !SuiteName().Compare( aFilter.SuiteName()) )

            {

            if ( aFilter.IsEvaluateSuite() )

                {

                iEvaluationNeeded = ETrue;

                }    

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

                {

                iItems[i]->MarkEvaluationL( aFilter );

                } 

            } 

        }

    else

        {

        if( aFilter.IsEvaluateSuite() )

            {

            iEvaluationNeeded = ETrue;

            }

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

           {

           iItems[i]->MarkEvaluationL( aFilter );

           } 

        }

    }

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

//

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

//

void CHnMdSuite::CreateItemsL( TXmlEngElement aElement,

                        THnMdCommonPointers* aCmnPtrs )

    {

    ASSERT( aElement.Name() == KSuiteElementName8 );

    // construction...

    RXmlEngNodeList< TXmlEngElement > elements;

    CleanupClosePushL( elements );

    aElement.GetChildElements( elements );

    TInt elementsCount = elements.Count();

    for (TInt j = 0; j < elementsCount; j++ )

        {

        TXmlEngElement element = elements.Next();

        if ( !element.Name().Compare( KItemElementName8 ) )

            {

            CHnMdItem *item = CHnMdItem::NewL( element, aCmnPtrs );

            CleanupStack::PushL( item );

            iItems.AppendL( item );

            CleanupStack::Pop( item );

            }

        }

    CleanupStack::PopAndDestroy( &elements );

    }

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

//

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

//

void CHnMdSuite::SetGenreL(const TDesC& aGenre)

    {

    iSuiteName.Close();

    iSuiteName.CreateL( aGenre );

    iSuiteName.LowerCase();

    DEBUG16(("\t_MM_: suite attribute (genre): %S", &aGenre ));

    }

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

//

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

//

void CHnMdSuite::SetGenreL(TXmlEngAttr aGenre)

    {

    HBufC* genre = HnConvUtils::Str8ToStrLC( aGenre.Value() );

    SetGenreL(*genre);

    // clean up

    CleanupStack::PopAndDestroy(genre);

    }

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

// 

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

//

void CHnMdSuite::SetTemplateL( TXmlEngAttr aTemplate )

    {

    SetTemplateL( aTemplate.Value() );

    }

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

// 

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

//

void CHnMdSuite::SetTemplateL( const TDesC8& aTemplate )

    {

    delete iAllowableTemplate;

    iAllowableTemplate = NULL;

    iAllowableTemplate = new ( ELeave ) CDesC8ArrayFlat( 3 );

    for (int i = 0; i < HnUtils::GetColumnTextColumnCount( aTemplate ); i++)

        {

        HBufC8* templateBuf = HnUtils::GetColumnTextLC( i, aTemplate );

        templateBuf->Des().Trim();

        iAllowableTemplate->AppendL( *templateBuf );

        CleanupStack::PopAndDestroy(templateBuf);

        }

    SetAlternativeTemplateL( GetAlternativeWidgetNumber() );

    }

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

// 

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

//

void CHnMdSuite::AddInternalStateL( CLiwGenericParamList& aParamList )

    {

    TLiwGenericParam param;

    param.PushL();

    CLiwDefaultMap* suiteMap = CLiwDefaultMap::NewL();

    suiteMap->PushL();

    TLiwVariant suiteWidgetTypeVariant;

    suiteWidgetTypeVariant.PushL();

    CLiwDefaultMap* widgetTypeMap = CLiwDefaultMap::NewL();

    widgetTypeMap->PushL();

    if ( iWidgetType == EGridWidget )

        {

        widgetTypeMap->InsertL( KWidgetType8(), KWidgetTypeGrid8() );

        }

    else if ( iWidgetType == EListWidget )

        {

        widgetTypeMap->InsertL( KWidgetType8(), KWidgetTypeList8() );

        }

    else if ( iWidgetType == ECoverFlowWidget )

        {

        widgetTypeMap->InsertL( KWidgetType8(), KWidgetTypeCoverFlow8() );

        }

    widgetTypeMap->InsertL( KAllowedTypes8(), iAllowedTypes );

    suiteWidgetTypeVariant.Set( widgetTypeMap );

    // add suite widget type

    suiteMap->InsertL( KSuite8(), suiteWidgetTypeVariant );

    aParamList.Remove( KMm8 );

    // set internal state

    param.SetNameAndValueL( KMm8, TLiwVariant( suiteMap ) );

    aParamList.AppendL( param );

    CleanupStack::PopAndDestroy( widgetTypeMap );

    CleanupStack::PopAndDestroy( &suiteWidgetTypeVariant );

    CleanupStack::PopAndDestroy( suiteMap );

    CleanupStack::PopAndDestroy( &param );

    }

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

// 

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

//

void CHnMdSuite::DoSetWidgetTypeL( TDesC8 & aConfDes )

    {

    if ( !aConfDes.Compare( KWidgetTypeGrid8 ))

        {

        iAllowableWidgetType.AppendL( EGridWidget );

        }

    else if ( !aConfDes.Compare( KWidgetTypeList8 ) )

        {

        iAllowableWidgetType.AppendL( EListWidget );        

        }

    else if ( !aConfDes.Compare( KWidgetTypeCoverFlow8 ) )

        {

        iAllowableWidgetType.AppendL( ECoverFlowWidget );                

        }

    }

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

//

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

//

EXPORT_C TInt CHnMdSuite::GetAlternativeWidgetNumber()

    {

    return iAllowableWidgetType.Find( iWidgetType );

    }

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

//

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

//

void CHnMdSuite::SetAlternativeTemplateL( TInt aOption )

    {

    iTemplate.Close();

    if (aOption >= 0 && aOption < iAllowableTemplate->Count())

        {

        const TDesC8 & val = (*iAllowableTemplate)[aOption];

        iTemplate.CreateL(val.Length());

        iTemplate.Copy(val);

        iTemplate.Trim();

        }

    else

        {

        iTemplate.CreateL( KNullDesC8() );

        }

    }

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

//

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

//

void CHnMdSuite::SetAlternativeTemplateL( CLiwGenericParamList& aParams )

    {

    RBuf8 logicalTemplate;

    logicalTemplate.CleanupClosePushL();

    if ( KErrNone == HnLiwUtils::GetStringL( 

            aParams, KTemplatePath8, logicalTemplate ) &&

            KErrNone != logicalTemplate.Compare( KTemplatePath8 ) &&

            logicalTemplate.Length() )

        {

        SetTemplateL( logicalTemplate );

        }

    else

    	{

    	SetAlternativeTemplateL( GetAlternativeWidgetNumber() );

    	}

    CleanupStack::PopAndDestroy( &logicalTemplate );

    }

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

//

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

//

TBool CHnMdSuite::ReadWidgetTypeFromServiceL( CLiwGenericParamList& aParams, 

        RBuf8& aWidgetType )

    {

    return 

        HnLiwUtils::GetStringL( aParams, KWidgetTypePath8, aWidgetType ) == KErrNone 

        && aWidgetType.Compare( KWidgetTypePath8 ) !=  KErrNone 

        && aWidgetType.Length();

    }

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

//

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

//

void CHnMdSuite::SetAlternativeWidgetL( CLiwGenericParamList& aParams )

    {

    RBuf8 widget;

    widget.CleanupClosePushL();

    if ( ReadWidgetTypeFromServiceL( aParams, widget )  )

        {

        iAllowableWidgetType.Reset();

        SetWidgetTypeL( widget );

        }

    else

        {

        ReadWidgetTypeL();

        }

    CleanupStack::PopAndDestroy( &widget );

    }

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

// 

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

//

void CHnMdSuite::SetWidgetTypeL( TXmlEngAttr aWidgetType )

    {