/*

* Copyright (c) 2009 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:   ?Description

*

*/

#include "iaupdatenodecontainer.h"

#include "iaupdatecontrollerimpl.h"

#include "iaupdatecontentoperationmanager.h"

#include "iaupdatenodeimpl.h"

#include "iaupdatefwnodeimpl.h"

#include "iaupdatenodedetails.h"

#include "iaupdatenodedependencyimpl.h"

#include "iaupdateplatformdependency.h"

#include "iaupdateutils.h"

#include "iaupdatenodefactory.h"

#include "iaupdatedebug.h"

// Constant that is used to inform that dependency node

// was not found when dependencies were checked.

const TInt KDependencyNotFound( -1 );

CIAUpdateNodeContainer* CIAUpdateNodeContainer::NewLC(

    CIAUpdateController& aController )

    {

    CIAUpdateNodeContainer *self = 

        new (ELeave) CIAUpdateNodeContainer( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CIAUpdateNodeContainer* CIAUpdateNodeContainer::NewL(

    CIAUpdateController& aController )

    {    

    CIAUpdateNodeContainer *self = 

        CIAUpdateNodeContainer::NewLC( aController );

    CleanupStack::Pop( self );

    return self;

    }

CIAUpdateNodeContainer::CIAUpdateNodeContainer(

    CIAUpdateController& aController )

: CBase(),

  iController( aController )

    {

    }

void CIAUpdateNodeContainer::ConstructL()

    {

    }

CIAUpdateNodeContainer::~CIAUpdateNodeContainer()

    {

    Clear();

    }    

void CIAUpdateNodeContainer::AddNodeL( CIAUpdateNode* aNode )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::AddNodeL() begin");

    if ( !aNode )

        {

        // Null is not acceptable

        IAUPDATE_TRACE("[IAUPDATE] LEAVE: Node null");

        User::Leave( KErrArgument );

        }

    CleanupStack::PushL( aNode );

    IAUPDATE_TRACE("[IAUPDATE] Check if node is acceptable");

    if ( !NodeAlreadyExists( *aNode )

         && aNode->Details().PlatformDependency().AcceptablePlatformL()

         && InstallCheckL( *aNode ) 

         && !aNode->Details().EmbededDegrades()

         && PackageTypeAcceptedL( *aNode ) )

        {

        IAUPDATE_TRACE("[IAUPDATE] Node accepted. Add into the node array.");

        // The node list will contain nodes 

        // that can be downloaded and installed.

        // The header node list will provide 

        // most recent version of the content.

        // The ownership of the node transfers.

        // So try to append it into the array.

        // If node can not be added into the array, 

        // it will be deleted when appending leaves.

        iNodes.AppendL( aNode );

        // Appending was successfull. 

        // So, ownership has been transferred successfully.

        CleanupStack::Pop( aNode );

        }

    else

        {

        IAUPDATE_TRACE("[IAUPDATE] Node not accepted. Delete it.");

        // Because the node is not deployable 

        // or it was for the wrong platform, 

        // there is no use for it. Delete the node.

        CleanupStack::PopAndDestroy( aNode );

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::AddNodeL() end");

    }

void CIAUpdateNodeContainer::AddExcessNodeL( CIAUpdateNode* aNode )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::AddExcessNodeL() begin");

    if ( aNode == NULL )

        {

        // Null is not acceptable

        IAUPDATE_TRACE("[IAUPDATE] LEAVE: NULL node");

        User::Leave( KErrArgument );

        }

    // The node list will contain nodes that do not belong to any other

    // node category.

    // The ownership of the node transfers.

    // So try to append it into the array.

    CleanupStack::PushL( aNode );

    iExcessNodes.AppendL( aNode );

    CleanupStack::Pop( aNode );

    // Force the node to be hidden.

    aNode->ForceHidden( ETrue );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::AddExcessNodeL() end");

    }

void CIAUpdateNodeContainer::AddFwNodeL( CIAUpdateFwNode* aNode )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::AddFwNodeL() begin");

    if ( !aNode )

        {

        // Null is not acceptable

        IAUPDATE_TRACE("[IAUPDATE] LEAVE: Node null");

        User::Leave( KErrArgument );

        }

    CleanupStack::PushL( aNode );

    iFwNodes.AppendL( aNode );

    CleanupStack::Pop( aNode );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::AddFwNodeL() end");

    }

void CIAUpdateNodeContainer::Clear()

    {

    // Just reset this list because all the nodes 

    // are owned by the iNodes list.

    iHeadNodes.Reset();

    // Reset the list and delete the nodes.

    iNodes.ResetAndDestroy();

    // Reset the list and delete the nodes.    

    iExcessNodes.ResetAndDestroy();

    // Reset the list and delete the nodes.

    iFwNodes.ResetAndDestroy();

    }

const RPointerArray< CIAUpdateNode >& CIAUpdateNodeContainer::AllNodes() const

    {

    return iNodes;

    }

const RPointerArray< CIAUpdateNode >& CIAUpdateNodeContainer::ExcessNodes() const

    {

    return iExcessNodes;

    }

const RPointerArray< CIAUpdateNode >& CIAUpdateNodeContainer::HeadNodesL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::HeadNodesL() begin");

    // Make sure that dependencies are correct. 

    // Notice, that here the dependencies are checked for all the nodes 

    // in the node list. So, some dependencies that may not be required 

    // are also checked. (Unnecessary dependency checks can exist, for example, 

    // if the server sends multiple update packets for a same content version.)

    // But, checking of dependencies first makes it easier to find correct header 

    // nodes later because we can be sure that all the nodes have intact dependency 

    // chains then. Also, notice that this function will set the information about 

    // the dependency checks into the nodes and remove nodes, whose dependencies

    // are broken, from the list.

    UpdateDependenciesL();

    // Create the header node list and remove nodes 

    // whose dependency chains are broken.

    ManageHeaderNodesL();

    // Create the dependecy for self update nodes 

    // and mark selfupdater and ncd hidden.

    // RemoveHiddenNodesFromHeadList will handle those nodes 

    // after they have been marked hidden.

    CreateSelfUpdateBundleL();

    // This will set the service pack dependency nodes as hidden.

    HandleServicePacksL();

    // Bundles may contain nodes that are head nodes

    // but have been marked hidden.

    // So, remove hidden nodes from the head list. 

    // Hidden nodes should be visible to UI.

    RemoveHiddenNodesFromHeadList();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::HeadNodesL() end");

    return iHeadNodes;

    }

const RPointerArray< CIAUpdateFwNode >& CIAUpdateNodeContainer::FwNodes()

    {

    return iFwNodes;    

    }

void CIAUpdateNodeContainer::UpdateDependenciesL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::UpdateDependenciesL() begin");

    // Reset node statuses

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

        {

        iNodes[ i ]->Reset();

        }

    // Check and update the dependencies for all the nodes.

    // So, it will be checked that all the nodes can be installed correctly

    // and no dependencies for them are missing.

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

        {

        // If the node dependency status has already been set, 

        // then it was already checked in some previous loop 

        // or recursion of dependency check. So, do not recheck 

        // the same branch here. Notice, the DependencyCheckStatus is 

        // also checked in the recursion in UpdateNodeDependenciesL. 

        // So, recheck should not even be allowed here. Otherwise checks

        // will fail unless the statuses are resetted before.

        // If the state has not been set, then check the branch.

        CIAUpdateNode& node( *iNodes[ i ] );

        if ( node.DependencyCheckStatus() 

             == CIAUpdateNode::EDependencyCheckNotSet )

            {

            // Notice, that this function sets the dependency check status 

            // for the node and to the nodes belonging to that branch in 

            // its dependency tree.

            UpdateNodeDependenciesL( node, 0 );

            }        

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::UpdateDependenciesL() end");

    }

TInt CIAUpdateNodeContainer::UpdateNodeDependenciesL( 

    CIAUpdateNode& aNode, TInt aDepth )

    {

    IAUPDATE_TRACE_2("[IAUPDATE] CIAUpdateNodeContainer::UpdateNodeDependenciesL() begin: %S, %S",

                     &aNode.MetaNamespace(), &aNode.MetaId());

    // Notice that this function creates a recursive loop together with 

    // FindBestMatchL function.

    // Check if we have already handled this node and dependency loops back to it.

    // If node check is already going on for the node, then there is loop in dependency.

    // Do not accept loops for dependencies. If no loop, then continue normally. 

    // Notice, that if we loop here, other sub branches may have not been

    // checked for this node yet. So, only set the status when the whole subtree has

    // been checked.

    if ( aNode.DependencyCheckStatus() 

         == CIAUpdateNode::EDependencyCheckNotSet )

        {

        IAUPDATE_TRACE("[IAUPDATE] Dependency check not set yet");

        // Gives the total leaf distance of this part of the dependency tree. 

        // The tallest branch gives the total leaf distance.    

        TInt totalLeafDistance( KDependencyNotFound );

        // Mark the check state here to prevent loops.

        aNode.SetDependencyCheckStatus( CIAUpdateNode::EDependencyCheckGoing );

        RPointerArray< CIAUpdateNodeDependency > deps;

        CleanupClosePushL( deps );

        // Get dependency objects from aNode into the deps array.

        // Get dependencies that were gotten from the server.

        aNode.Details().GetDependenciesL( deps );

        // Now, that we have the dependency information for the given node,

        // find the nodes that provide the best dependency branches.            

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

            {

            // The best branch is thought to be the branch that is the flattest.

            // FindBestMatchL function inserts the best match information 

            // to the dependency object. The best match information of the dependency 

            // will contain the possible node whose content is required 

            // for the dependency chain to be complete. Also, that node may need other nodes. 

            // So, the dependency branch may continue there.

            // Dependency depth is one greater than the depth of dependant aNode.

            TInt leafDistance( 

                FindBestMatchL( aNode, *deps[ i ], aDepth + 1 ) );

            // Notice, that here we are looking for the total leaf distance for this branch.

            // FindBestMatchL -function that is used above will use this value to check 

            // what branch has the shortes totalLeafDistance. 

            // The branch that is flattest will be chosen for the current parent node.

            if ( leafDistance == KDependencyNotFound )

                {

                IAUPDATE_TRACE("[IAUPDATE] Dependency check failed");

                // Because dependency was not found from the node list or from 

                // the installed applications, the node dependency chain is broken.

                // Set this information into the node.

                // So, this node will be removed from the node list later.

                aNode.SetDependencyCheckStatus( CIAUpdateNode::EDependencyCheckFailed );

                // Because, one missing item is enough to break the chain, just return here.

                // If other nodes are required, they are checked separately later in their own

                // checkings. The chain break affects all the nodes that depend on this one. So,

                // this information will be set to the nodes, when the recursion goes back.

                CleanupStack::PopAndDestroy( &deps );

                IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::UpdateNodeDependenciesL() end: KDependencyNotFound");

                return KDependencyNotFound;            

                }

             else if ( totalLeafDistance < leafDistance )

                {

                IAUPDATE_TRACE_2("[IAUPDATE] Replace old totalLeafDistance %d, %d",

                                 totalLeafDistance, leafDistance);

                // Set the total leaf distance of this part of the dependency chain because

                // the chain is intact.

                totalLeafDistance = leafDistance;

                }            

            }

        CleanupStack::PopAndDestroy( &deps );

        // Dependency chain for the node is intact.

        // Set this information into the node.    

        aNode.SetDependencyCheckStatus( CIAUpdateNode::EDependencyCheckPassed );

        IAUPDATE_TRACE("[IAUPDATE] EDependencyCheckPassed");

        // Add one, so the parent will get its own actual leaf distance in return.

        ++totalLeafDistance;

        // Also, set the total leaf distance for the node.

        aNode.SetLeafDistance( totalLeafDistance );

        IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateNodeContainer::UpdateNodeDependenciesL() end: %d",

                         totalLeafDistance);

        return totalLeafDistance;    

        }

    else if ( aNode.DependencyCheckStatus()

              == CIAUpdateNode::EDependencyCheckPassed )

        {

        IAUPDATE_TRACE("[IAUPDATE] Dependency check already passed");

        // Because this node and the hierarchy below it has already been handled,

        // check if the depth of the node and its dependency hierarchy should be

        // updated with the new value. 

        aNode.UpdateDependencyDepthsL( aDepth );

        // Because we have already handled this branch successfully,

        // just return its own leaf distance information.

        IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateNodeContainer::UpdateNodeDependenciesL() end: %d",

                         aNode.LeafDistance());

        return aNode.LeafDistance();

        }

    else if ( aNode.DependencyCheckStatus()

              == CIAUpdateNode::EDependencyCheckGoing )

        {

        IAUPDATE_TRACE("[IAUPDATE] Dependency loop has occurred");

        // Notice, we come here if there are loops in dependencies.

        // Looping dependency chains are not acceptable in normal cases.

        // Notice, in case of service packs, if another branch of service pack

        // is intact and it does not loop, then the service pack check status 

        // is set to CIAUpdateNode::EDependencyCheckPassed when the recursion 

        // is over above and all the branches of the service pack have been handled. 

        // Still loopin branches inside service pack will also be removed.

        aNode.SetDependencyCheckStatus( CIAUpdateNode::EDependencyCheckFailed );

        }

    // We come here if dependency check status has been set to 

    // CIAUpdateNode::EDependencyCheckFailed. So, then always 

    // return KDependencyNotFound to correspond that situation.

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::UpdateNodeDependenciesL() end: KDependencyNotFound");

    return KDependencyNotFound;

    }

TInt CIAUpdateNodeContainer::FindBestMatchL( CIAUpdateNode& aNode,

                                             CIAUpdateNodeDependency& aDependency,

                                             TInt aDependencyDepth )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNodeContainer::FindBestMatchL() begin");

    // Notice that this function creates a recursive loop together with 

    // UpdateNodeDependenciesL function.

    // As a default, the dependency we are looking for is marked as not found.

    TInt totalLeafDistance( KDependencyNotFound );

    // Check if the dependency file has already been installed and get the version

    // of the application if it has been installed.

    TIAUpdateVersion installedVersion;

    TBool installed( 

        IAUpdateUtils::IsAppInstalledL( 

            aDependency.Uid(), installedVersion ) );

    if ( aDependency.IsEmbedded() )

        {

        IAUPDATE_TRACE("[IAUPDATE] Dependency is embedded in the node.");

        // If dependency node is already embedded into the package, then use it

        // instead of downloading it separately. Embedded dependencies are always

        // matched by the node itself. Embedded package has to be installed 

        // when content is installed, or the whole installation fails.

        // Best match for this dependency is the node content itself. But, 

        // to prevent loops, set the best match to NULL.

        aDependency.SetBestMatch( NULL );

        // If the embedded node will require downgrades, 

        // then do not accept this dependency. Notice, here we think 

        // that the embedded content version value is given as version roof value.

        // So, the installed version has to be equal or smaller than the roof value,

        // if the embedded content can be accepted.

        // Note for future improvements: 

        // When support is added for embedded sisx to have dependencies, 

        // this needs to be changed accordingly

        if ( !installed

             || installedVersion <= aDependency.VersionRoof() )

            {

            IAUPDATE_TRACE("[IAUPDATE] Embedded content can be installed");

            // Leaf distance is zero because embedded item is already part

            // of the node itself.

            totalLeafDistance = 0;           

            }

        }

    else

        {

        IAUPDATE_TRACE("[IAUPDATE] Dependency content is not embedded.");

        // Check here if the best matching content is already installed or if

        // content needs to be downloaded and installed

        // Note, that the dependency may also describe an update dependency

        // for the content instead of just describing that a content depends 

        // on another content. But, we can handle it all these cases in a same

        // way.

        // This value will be updated when the recursive call of 

        // UpdateNodeDependenciesL inside for-loop has found an acceptable leaf node. 

        // Then, recursion will come back of the tree hierarchy and find other branches 

        // and update this value if necessary.

        CIAUpdateNode* currentBestMatch( NULL );

        RPointerArray< CIAUpdateNode > matches;

        CleanupClosePushL( matches );

        // Find the nodes that fullfill the given dependency requirement.

        // Node list may contain multiple alternatives. 

        // So, first find the alternatives.

        // Notice, that this function skips already installed items.

        FindMatchesL( matches, aDependency );

        // Find the best match from the alternatives.

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

            {

            CIAUpdateNode& tmpNode( *matches[ i ] );

            // The node that matches can be part of the best dependency branch.

            // But, we still need to check the whole branch before we can be sure. 

            // So, check the dependency branch forward by using the recursion.

            TInt leafDistance( 

                UpdateNodeDependenciesL( tmpNode, aDependencyDepth ) );

            // If no match has been handled so far, then the new one is best match.

            // If there is already a current best match, then check if the

            // new one should replace it.

            if ( leafDistance != KDependencyNotFound 

                 && ( totalLeafDistance == KDependencyNotFound 

                      || currentBestMatch 

                         && ReplaceRecommendedL( 

                                *currentBestMatch, tmpNode ) ) )

                {

                IAUPDATE_TRACE("[IAUPDATE] New best match found.");

                currentBestMatch = &tmpNode;

                totalLeafDistance = leafDistance;