/*
* 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 "hnmdeventmapping.h"
#include "hnmdeventmappingelement.h"
#include "hnmdevent.h"
#include "hneventhandler.h"
#include "hnsuitemodel.h"
#include "hnitemmodel.h"
#include "hnmdaction.h"
#include "hnactionmodel.h"

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

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
RPointerArray<CHnMdAction> CHnMdEventMapping::GetActionsForEventId(
    TInt aEventId )
    {
    RPointerArray<CHnMdAction> emptyActions;
    CHnMdEventMappingElement* eventMappingElement = NULL;
    TBool eventIdFound( EFalse );

    TInt mappingCount( Count() );

    for ( TInt i = 0; i < mappingCount; i++ )
        {
        CHnMdEventMappingElement* eme = iMappings[i];

        RPointerArray<CHnMdEvent> events = eme->Events();

        TInt actionsCount = events.Count();

        for ( TInt j = 0; j < actionsCount; j++ )
            {
            CHnMdEvent* event = events[ j ];

            if (event->Id() == aEventId )
                {
                eventIdFound = ETrue;
                break;
                }
            }
        if ( eventIdFound )
            {
            eventMappingElement = eme;
            break;
            }
        }

    if ( eventIdFound )
        return eventMappingElement->Actions();
    else
        return emptyActions;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdEventMapping::ConstructL( TXmlEngElement aElement, THnMdCommonPointers* aCmnPtrs )
    {
    // construction...
    iCmnPtrs = aCmnPtrs;

    RXmlEngNodeList< TXmlEngElement > children;
    CleanupClosePushL(children);

    aElement.GetChildElements(children);
    TInt amount = children.Count();

    for (TInt i(0);i<amount;i++)
        {
        TXmlEngElement child = children.Next();
        if ( !child.Name().Compare( KEventElementName8 ) )
            {
            CHnMdEventMappingElement* eme =
                CHnMdEventMappingElement::NewL( child );
            CleanupStack::PushL( eme );
            iMappings.AppendL( eme );
            CleanupStack::Pop( eme );
            }
        }

    CleanupStack::PopAndDestroy( &children );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdEventMapping* CHnMdEventMapping::NewL( TXmlEngElement aElement,
        THnMdCommonPointers* aCmnPtrs )
    {
    CHnMdEventMapping* self = CHnMdEventMapping::NewLC( aElement,
        aCmnPtrs );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CHnMdEventMapping::Count() const
    {
    return iMappings.Count();
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdEventMapping* CHnMdEventMapping::NewLC( TXmlEngElement aElement,
        THnMdCommonPointers* aCmnPtrs )
    {
    CHnMdEventMapping* self = new( ELeave ) CHnMdEventMapping;
    CleanupStack::PushL( self );
    self->ConstructL( aElement, aCmnPtrs );
    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdEventMapping::CHnMdEventMapping()
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnMdEventMapping::~CHnMdEventMapping()
    {
    iMappings.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdEventMapping::AddActionL(
        RHashMap<TInt,CArrayPtr<CHnActionModel> *> & aActions,
        CHnActionModel *& aActionModel, TInt aEventId )
    {
    CArrayPtr<CHnActionModel>** actionsContainer = aActions.Find( aEventId );
    if ( !actionsContainer )
        {
        CArrayPtr<CHnActionModel>* newActionsContainer = new(
            ELeave ) CArrayPtrFlat<CHnActionModel>( KDefaultGranularity );
        CleanupStack::PushL( newActionsContainer );
        aActions.InsertL( aEventId, newActionsContainer );
        actionsContainer = &newActionsContainer;
        CleanupStack::Pop( newActionsContainer );
        }
    ( *actionsContainer )->AppendL( aActionModel );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdEventMapping::FillActionsL(
        RHashMap< TInt, CArrayPtr<CHnActionModel>* >& aActions,
        const CLiwGenericParamList& aQueriesResultsList, TInt aPos )
    {
    RArray< TInt > eventIds;
    CleanupClosePushL( eventIds );
    GetEventIdsL( eventIds );

    for ( TInt i( 0 ); i < eventIds.Count(); i++ )
        {
        RPointerArray< CHnMdAction > actions = GetActionsForEventId(
                eventIds[ i ] );
        for ( TInt j( 0 ); j < actions.Count(); j++ )
            {
            if ( !actions[ j ] || !actions[ j ]->IsValidL(
                    aQueriesResultsList, aPos ) )
                {
                continue;
                }
            CHnActionModel* actionModel = CHnActionModel::NewL();
            CleanupStack::PushL( actionModel );
            actions[ j ]->EvaluateL( actionModel, aQueriesResultsList, aPos );
            AddActionL( aActions, actionModel, eventIds[ i ] );
            CleanupStack::Pop( actionModel );
            }
        }
    CleanupStack::PopAndDestroy( &eventIds );
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnMdEventMapping::GetEventIdsL( RArray< TInt >& aIds ) const
    {
    TInt mappingCount = Count();

    for( TInt i = 0; i < mappingCount; i++ )
        {
        CHnMdEventMappingElement* eme = iMappings[ i ];
        const RPointerArray< CHnMdEvent >& events = eme->Events();
        TInt eventsCount = events.Count();
        for ( TInt j = 0; j < eventsCount; j++ )
            {
            CHnMdEvent* event = events[ j ];
            aIds.AppendL( event->Id() );
            }
        }
    }