/*

* Copyright (c) 2007-2010 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:   This module contains the description of CIAUpdateNodeFilter 

*                class member functions.

*

*/

#include <e32property.h>

#include <iaupdateparameters.h>

#include <centralrepository.h>

#include "iaupdatenodefilter.h"

#include "iaupdatebasenode.h"

#include "iaupdatenode.h"

#include "iaupdatefwnode.h"

#include "iaupdateutils.h"

#include "iaupdatedeputils.h"

#include "iaupdateuids.h"

#include "iaupdatedebug.h"

#include "iaupdatefwnsmlpskeys.h"

#include "iaupdatefwupdatehandler.h"

#include "iaupdateprivatecrkeys.h"

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

// CIAUpdateNodeFilter::NewL

// Two-phased constructor.

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

//

CIAUpdateNodeFilter* CIAUpdateNodeFilter::NewL()

    {

    CIAUpdateNodeFilter* self =

        CIAUpdateNodeFilter::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CIAUpdateNodeFilter::NewLC

// Two-phased constructor.

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

//    

CIAUpdateNodeFilter* CIAUpdateNodeFilter::NewLC()

    {

    CIAUpdateNodeFilter* self =

        new( ELeave ) CIAUpdateNodeFilter();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CIAUpdateNodeFilter::~CIAUpdateNodeFilter

// Destructor

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

// 

CIAUpdateNodeFilter::~CIAUpdateNodeFilter()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::~CIAUpdateNodeFilter() begin");

    delete iFilterParams;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::~CIAUpdateNodeFilter() end");

    }

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

// CIAUpdateNodeFilter::CIAUpdateNodeFilter

// c++ constructor

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

// 

CIAUpdateNodeFilter::CIAUpdateNodeFilter()

: CBase()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CIAUpdateNodeFilter()");

    }

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

// CIAUpdateNodeFilter::ConstructL

// 

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

//

void CIAUpdateNodeFilter::ConstructL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::ConstructL()");    

    }

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

// CIAUpdateNodeFilter::SetFilterParams

// 

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

//

void CIAUpdateNodeFilter::SetFilterParams( CIAUpdateParameters* aParams )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::SetFilterParams() begin");

    delete iFilterParams;

    iFilterParams = aParams;    

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::SetFilterParams() end");

    }

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

// CIAUpdateNodeFilter::FilterParams

// 

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

//    

CIAUpdateParameters* CIAUpdateNodeFilter::FilterParams() const

   {

   return iFilterParams; 	

   }

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

// CIAUpdateNodeFilter::FilterAndSortNodesL

// 

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

//

void CIAUpdateNodeFilter::FilterAndSortNodesL( 

                          RPointerArray< MIAUpdateNode >& aNodes,

                          RPointerArray< MIAUpdateFwNode >& aFwNodes )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::FilterAndSortNodesL() begin");

    // Just to make sure that filter has the correct UID set.

    // Checks if the filter UID was SID and changes it to pUID if possible.

    TUid pUid( PackageUidL( aNodes ) );

    // Use bubble sort to sort the array

    TInt tmpIndex( aNodes.Count() );

    if ( tmpIndex == 1 )

        {

        IAUPDATE_TRACE("[IAUPDATE] Only one node.");

        // If the array has only one node, no need to do sorting. 

        // Instead, just check if the node needs to be marked or not. 

        MarkFilterNodeL( *aNodes[ 0 ], pUid );

        }

    else if ( tmpIndex > 1 )

        {

        IAUPDATE_TRACE_1("[IAUPDATE] Multiple nodes: %d", tmpIndex);

        // There are multiple nodes in the array.

        // So, sorting may be required.

        TBool swapped( EFalse );

        do

            {

            swapped = EFalse;

            --tmpIndex;

            for ( TInt i = 0; i < tmpIndex; ++i )

                {

                // Check if the aNodes[ i ] should be after aNodes[ i + 1 ]

                // in the array.

                if ( CompareAndMarkFilterNodesL( 

                        *aNodes[ i ], 

                        *aNodes[ i + 1 ],

                        pUid ) )

                    {

                    // Swap the nodes

                    MIAUpdateNode* tmpNode( aNodes[ i ] );

                    aNodes[ i ] = aNodes[ i + 1 ];

                    aNodes[ i + 1 ] = tmpNode;

                    swapped = ETrue;

                    }

                }        

            } while( swapped );

        }    

    // When dependant is marked, all dependencies to be marked also

    for ( TInt i = 0; i < aNodes.Count(); ++i )

        {

        MIAUpdateNode* node( aNodes[ i ] );

        if ( node->Base().IsSelected() )

            {

            SetDependenciesSelectedL( *node, aNodes );

            }

        }

    // Now update nodes were handled

    // Let's handle firmware updates

    if ( aFwNodes.Count() > 0  && DMSupportL() )

        {

        if ( iFilterParams )

            {

            if ( iFilterParams->Uid() != TUid::Null() ||

                 iFilterParams->SearchCriteria() != KNullDesC() )

                { //UID or search criteria given, firmware updates are not shown at all

                aFwNodes.Reset();

                }

            else

                {

                if ( aFwNodes.Count() == 1 && aFwNodes[0]->FwType() == MIAUpdateFwNode::EFotiNsu )

                    {

                    aFwNodes[0]->Base().SetSelected( EFalse );

                    }

                else

                    {

                    for ( TInt i = 0; i < aFwNodes.Count(); ++i )   

                        {

                        }

                    for ( TInt i = 0; i < aNodes.Count(); ++i )   

                        {

                        aNodes[i]->Base().SetSelected( EFalse );

                        }

                    }

                }

            }

        else

            {

            if ( aFwNodes.Count() == 1 && aFwNodes[0]->FwType() == MIAUpdateFwNode::EFotiNsu )

                {

                aFwNodes[0]->Base().SetSelected( EFalse );

                }

            else

                {

                for ( TInt i = 0; i < aFwNodes.Count(); ++i )   

                    {

                    }

                for ( TInt i = 0; i < aNodes.Count(); ++i )   

                    {

                    aNodes[i]->Base().SetSelected( EFalse );

                    }

                }

            }

        }

    else

        {

        aFwNodes.Reset();

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::FilterAndSortNodesL() end");

    }

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

// CIAUpdateNodeFilter::CountOfAvailableUpdatesL

// 

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

//

void CIAUpdateNodeFilter::CountOfAvailableUpdatesL( 

    const RPointerArray< MIAUpdateNode >& aNodes, 

    const RPointerArray< MIAUpdateFwNode >& aFwNodes, 

    TInt& aCount ) 

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() begin");

    aCount = 0; 

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() Node count (only MIAUpdateNodes): %d", aNodes.Count() );

    if ( iFilterParams->Type() & CIAUpdateParameters::ESis )

        {

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() ESis included in type parameter");

        if ( iFilterParams->Uid() == TUid::Null() 

             && iFilterParams->SearchCriteria() == KNullDesC() 

             && !FilteredByImportance() )

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() No filter values. Count all nodes.");

            // Because no filter values were given, 

            // all nodes should be counted.

            aCount = aNodes.Count();

            }

        else

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() Some filter values given.");

            // Some filter values were given.

            // So, filter nodes.        

            for ( TInt i = 0; i < aNodes.Count(); ++i )

                {

                if ( ImportanceMatches( *aNodes[ i ] ) )

                    {

                    if ( iFilterParams->Uid() == TUid::Null() && iFilterParams->SearchCriteria() == KNullDesC() )

                        {

                        ++aCount;

                        }

                    // If UID was given, filter by using UID.

                    // If UID was not given, filter by using search criteria.

                    else if ( iFilterParams->Uid() != TUid::Null() && iFilterParams->Uid() == aNodes[ i ]->Base().Uid()

                        || ( iFilterParams->Uid() == TUid::Null() 

                            && aNodes[ i ]->Base().SearchCriteria() != KNullDesC()

                            && SearchCriteriaMatches( iFilterParams->SearchCriteria(), aNodes[ i ]->Base().SearchCriteria() ) ) )

                        {

                        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() Filter parameters matched the node");

                        // Filter parameters matched the node.

                        ++aCount;

                        }

                    else if ( FilterCheckForServicePackL( *aNodes[ i ], 

                                                          iFilterParams->Uid(), 

                                                          iFilterParams->SearchCriteria() ) )

                        {

                        ++aCount;    

                        }

                    }

                }

            if ( iFilterParams->Uid() != TUid::Null() && aCount == 0 )

                {

                IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() Uid did not match. Is it SID?");

                // Uid did not match to anything in the list.

                // Maybe it was not a package UID but SID.

                // So, check if we can find out the package UID and use it.

                TUid newUid( 

                       IAUpdateUtils::AppPackageUidL( iFilterParams->Uid() ) );

                IAUPDATE_TRACE_2("[IAUPDATE] [IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() NewUid: %d, Old uid: %d", 

                                     newUid.iUid, iFilterParams->Uid() );

                if ( newUid != TUid::Null() && newUid != iFilterParams->Uid() )

                    {

                    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() New UID found."); 

                    // It was SID but now we know pUID.

                    // So, retry the search.

                    for ( TInt i = 0; i < aNodes.Count(); ++i )

                        {

                        if ( ImportanceMatches( *aNodes[ i ] ) )

                            {

                            if ( newUid == aNodes[ i ]->Base().Uid() )

                                {

                                IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() New UID matched.");

                                // New uid matched with the node uid.

                                ++aCount;

                                }

                            else if ( FilterCheckForServicePackL( *aNodes[ i ], 

                                     newUid, 

                                     iFilterParams->SearchCriteria() ) )

                                {

                                ++aCount;

                                }

                            }

                        }

                    }

                }

            }

        }

    // Firmware updates are not counted if UID or search criteria parameter exists 

    if ( iFilterParams->Uid() == TUid::Null() &&

         iFilterParams->SearchCriteria() == KNullDesC() )

        {

        TBool dmsupport = DMSupportL();

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() Checking DM support");

        //take firmware into account when dm support is available

        if ( dmsupport )

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() DM is supported");

            for ( TInt i = 0; i < aFwNodes.Count(); ++i )   

                {

                if ( aFwNodes[i]->FwType() == MIAUpdateFwNode::EFotaDp2 )

                    {

                    if ( iFilterParams->Type() & CIAUpdateParameters::EFota )

                        {

                        ++aCount;

                        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() FOTA node found");

                        }

                    }

                else if ( aFwNodes[i]->FwType() == MIAUpdateFwNode::EFotiNsu )  

                    {

                    if ( iFilterParams->Type() & CIAUpdateParameters::ENsu )

                         {

                         ++aCount;

                         IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() NSU node found");

                         }       

                    }

                }

            }

        }

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateNodeFilter::CountOfAvailableUpdatesL() end count:  %d",

                     aCount );

    }

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

// CIAUpdateNodeFilter::SetDependenciesSelectedL();

// 

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

//

void CIAUpdateNodeFilter::SetDependenciesSelectedL( MIAUpdateNode& aNode, 

                                 const RPointerArray<MIAUpdateNode>& aAllNodes ) 

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::SetDependenciesSelectedL() begin"); 

    RPointerArray<MIAUpdateNode> deps;

    CleanupClosePushL( deps );

    TInt depCount = deps.Count();

    for( TInt i = 0; i < depCount; i++ )

        {

        TInt depNodeInd = aAllNodes.Find( deps[i] );

        aAllNodes[depNodeInd]->Base().SetSelected( ETrue );

        }

    CleanupStack::PopAndDestroy( &deps );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::SetDependenciesSelectedL() end");

    }

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

// CIAUpdateNodeFilter::CompareAndMarkFilterNodesL

// 

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

//

TBool CIAUpdateNodeFilter::CompareAndMarkFilterNodesL( 

    MIAUpdateNode& aNode1, 

    MIAUpdateNode& aNode2,

    const TUid& aPackageUid )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CompareAndMarkFilterNodesL() begin");

    TBool filterCheck1( MarkFilterNodeL( aNode1, aPackageUid ) );

    TBool filterCheck2( MarkFilterNodeL( aNode2, aPackageUid ) );

    // 1. The one node that matches filter should be first.

    // 2. More ciritical should be first.

    // 3. Alphabetical order inside critical sets.

    if ( filterCheck1 && !filterCheck2 )

        {

        IAUPDATE_TRACE("[IAUPDATE] Only node 1 marked for filter.");

        // The Node1 should be before Node2 

        // if Node1 matches the filter check 

        // but Node2 does not.

        // Then, the importance or name does not have effect.

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CompareAndMarkFilterNodesL() end: EFalse");

        return EFalse;

        }

    else if ( !filterCheck1 && filterCheck2  

              || aNode1.Base().Importance() < aNode2.Base().Importance()

              || ( aNode1.Base().Importance() == aNode2.Base().Importance()

                   && aNode1.Base().Name().CompareC( aNode2.Base().Name() ) > 0 ) ) 

        {

        // Node2 should be before Node1.

        // Notice, that when comparing the node names, the comparison is thought

        // case-insensitive. Also, CompareC is used instead of CompareF because CompareC

        // uses collation method for narrow text appropriate to the current locale. CompareF

        // would be locale-independent behaviour.

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CompareAndMarkFilterNodesL() end: ETrue");

        return ETrue;

        }

    else

        {

        // Node1 should be before Node2.

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::CompareAndMarkFilterNodesL() end: EFalse");

        return EFalse;

        }

    } 

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

// CIAUpdateNodeFilter::MarkFilterNodeL

// 

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

//

TBool CIAUpdateNodeFilter::MarkFilterNodeL( 

    MIAUpdateNode& aNode,

    const TUid& aPackageUid )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeFilter::MarkFilterNodeL() begin");

    // This describes if the node matches the filter parameter.

    TBool filterCheck( EFalse );

    if ( iFilterParams )

        {

        // Notice, that when filtering was started the UID check was also done.

        // So, if the SID was given and it did not result to any matches,

        // then the filter UID was changed to corresponding package UID if

        // it was possible.

        // Notice, that if UID is given then use it for filtering.

        // If UID is not given, then use search criteria if it is given.

        if ( aPackageUid != TUid::Null() )

            {

            // Because uid was given, filter by using that value

            if ( aPackageUid == aNode.Base().Uid() )

                {

                // Because this matches the filter, set the node as selected

                aNode.Base().SetSelected( ETrue );

                filterCheck = ETrue;

                }

            else if ( FilterCheckForServicePackL( aNode, aPackageUid, iFilterParams->SearchCriteria() ) )

                {

                aNode.Base().SetSelected( ETrue );

                filterCheck = ETrue;    

                }

            }

        else if ( iFilterParams->SearchCriteria() != KNullDesC() )

            {

            // Because search criteria was given, use it for filtering

            if ( SearchCriteriaMatches( iFilterParams->SearchCriteria(), aNode.Base().SearchCriteria() ) )

                {

                // Because this matches the filter, set the node as selected

                aNode.Base().SetSelected( ETrue );

                filterCheck = ETrue;

                }

            else if ( FilterCheckForServicePackL( aNode, aPackageUid, iFilterParams->SearchCriteria() ) )

                {