/*

* Copyright (c) 2007 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:  Implements the collection cache

*

*/

// INCLUDES

#include <e32base.h>

#include <mpxitemid.h>

#include <mpxcmn.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcollectionopenlresultdef.h>

#include <mpxlog.h>

#include "mpxcollectioncache.h"

// CONSTANTS

const TInt KMPXRootNodeId = 0;

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

// static function to compare two datablock items

// used for sorting datablocks

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

//

static TInt CompareOpenDataBlock( const TMPXOpenDataBlock& aFirst,

                                  const TMPXOpenDataBlock& aSecond )

    {

    return aFirst.iOffset > aSecond.iOffset;

    }

/**

* Encapsulates a node in the cache tree.

*/

NONSHARABLE_CLASS(CMPXCollectionCacheNode) :

    public CBase

    {

public:

    /**

    * Two phase constructor.

    */

    static CMPXCollectionCacheNode* NewL( const TMPXItemId aId );

    /**

    * Destructor.

    */

    virtual ~CMPXCollectionCacheNode();

    /**

    * Adds a child to the current node.

    * Ownership of the node is transferred

    */

    void AddChildL(CMPXCollectionCacheNode* aChild);

    /**

    * Removes a child from the current node.

    * Ownership of the node is not transferred

    */

    void RemoveChild(CMPXCollectionCacheNode& aChild);

    /**

    * Retrieves a child by ID. Returns NULL if not found.

    * Ownership of the node is not transferred.

    */

    CMPXCollectionCacheNode* GetChild(TMPXItemId aId);

    /**

    * Sets the results and attribute set for the current node.

    * @param aAttrs list of open attributes

    * @param aResults results to set in

    * @param aMediaFromOpen is the media from common

    */

    void SetResultsL(

        const TArray<TMPXAttribute>& aAttrs,

        CMPXMedia& aResults,

        TBool aMediaFromOpen );

    /**

    * Checks if the specified attribute set exists (is included) in the current

    * node attribute set.

    */

    TBool AttributesExist(const TArray<TMPXAttribute>& aAttrs);

    /**

    * Checks if the specified attribute set exists (is included) in the current

    * node attribute set.

    */

    TBool ContainerAttributesExist(const TArray<TMPXAttribute>& aAttrs);

    /**

    * Checks if the specified attribute exists (is included) in the current

    * node attribute set.

    * @param aAttribute attribute to look for

    * @param aArray array to check

    * @return ETrue if found, EFalse if not found

    */

    TBool AttributeExists(const TMPXAttribute& aAttribute, 

                          RArray<TMPXAttribute>& aArray );

    /**

    * Checks this node and all child nodes for invalidated data

    * @param aChangeItemId ID of the item modified

    * @param aArray array to store the list of affected nodes

    */

    void HandleChangeL( TMPXItemId aChangeItemId, 

                        RPointerArray<CMPXCollectionCacheNode>& aArray );

#ifdef _DEBUG

    /**

    * Prints the node.

    */

    void PrintNode(TBool aPrintChildren, TBool aPrintAtts);

#endif

private:

    /**

    * C++ constructor

    */

    CMPXCollectionCacheNode(TMPXItemId aId,

        CMPXCollectionCache::TCachePriority aPriority);

    /**

    * Second phase constructor.

    */

    void ConstructL();

    /**

    * Returns the child index for the specified ID or KErrNotFound if not found.

    */

    TInt IndexOfId(TMPXItemId aId);

    /**

    * Compares two media instances. If the instances refer to the same collection

    * item (they have the same general ID) returns ETrue, otherwise EFalse.

    */

    TBool CompareMediaItemsL(

        const CMPXMedia& aMedia1, 

        const CMPXMedia& aMedia2 );

    /**

    *  Comparison method for node IDs. Used when searching child nodes by ID.

    *  Ownership of nodes is not transferred.

    *  This method is used with the Find method of RPointerArray and 

    *  must be declared as follow:

    *  TBool *(aFunction)(const K *k, const T &t);

    */

    static TBool CompareIDs(

        const CMPXCollectionCacheNode* aNode1,

        const CMPXCollectionCacheNode& aNode2 );

    /**

    * Merge the data from two arrays

    * @param aExistingArray Old array with current data

    * @param aNewArray New arrary with data to merge

    */

    TBool DoMergeMediaArraysL( const CMPXMediaArray& aExistingArray, 

                               const CMPXMediaArray& aNewArray );

    /**

    * Merge the data from two arrays

    * @param aExistingArray Old array with current data

    * @param aNewArray New arrary with data to insert

    */

    void DoInsertMediaArraysL( CMPXMediaArray& aExistingArray, 

                               const CMPXMediaArray& aNewArray, 

                               const TMPXOpenDataBlock& aBlock );

    /**

    * Compact a list of open datablocks into larger chunks

    * @param aArray Array to compact

    */

    void DoMergeArrayL( RArray<TMPXOpenDataBlock>& aArray );

public:

    TMPXItemId iId;                                 // node ID (same as path node ID)

    RArray<TMPXAttribute> iAttrs;                   // attribute set corresponding to the results

    RArray<TMPXAttribute> iContainerAttrs;          // attribute set corresponding to the container 

                                                    // of a result set

    CMPXMedia* iResults;                            // results

    CMPXCollectionCache::TCachePriority iPriority;  // node priority

    TTime iTime;                                    // last time the node was updated

    TInt iLevel;                                    // level of the node in the original path

    CMPXCollectionCacheNode* iParent;               // parent of the node (NULL for root)

    RPointerArray<CMPXCollectionCacheNode> iChildren;   // node children

    TBool iMediaFromOpenL;                          // whether or not this media was from an openl

    };

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

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

// CMPXCollectionCacheNode::NewL

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

//

CMPXCollectionCacheNode* CMPXCollectionCacheNode::NewL(

    const TMPXItemId aId)

    {

    MPX_FUNC("CMPXCollectionCacheNode::NewL");

    CMPXCollectionCacheNode* self = new(ELeave)CMPXCollectionCacheNode(aId,

        CMPXCollectionCache::EPriorityNormal);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMPXCollectionCacheNode::~CMPXCollectionCacheNode

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

//

CMPXCollectionCacheNode::~CMPXCollectionCacheNode()

    {

    MPX_FUNC("CMPXCollectionCacheNode::~CMPXCollectionCacheNode");

    iAttrs.Close();

    iContainerAttrs.Close();

    delete iResults;

    // delete all children

    iChildren.ResetAndDestroy();

    }

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

// CMPXCollectionCacheNode::CMPXCollectionCacheNode

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

//

CMPXCollectionCacheNode::CMPXCollectionCacheNode(

    TMPXItemId aId,

    CMPXCollectionCache::TCachePriority aPriority) :

    iId(aId),

    iPriority(aPriority)

    {

    MPX_FUNC("CMPXCollectionCacheNode::CMPXCollectionCacheNode");

    }

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

// CMPXCollectionCacheNode::ConstructL

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

//

void CMPXCollectionCacheNode::ConstructL()

    {

    MPX_FUNC("CMPXCollectionCacheNode::ConstructL");

    }

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

// CMPXCollectionCacheNode::AddChildL

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

//

void CMPXCollectionCacheNode::AddChildL(

    CMPXCollectionCacheNode* aChild)

    {

    MPX_FUNC("CMPXCollectionCacheNode::AddChildL");

    aChild->iParent = this;

    iChildren.AppendL(aChild);

    }

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

// CMPXCollectionCacheNode::RemoveChild

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

//

void CMPXCollectionCacheNode::RemoveChild(

    CMPXCollectionCacheNode& aChild)

    {

    MPX_FUNC("CMPXCollectionCacheNode::RemoveChild");

    TInt index = IndexOfId(aChild.iId);

    if (index != KErrNotFound)

        {

        // remove the child

        iChildren.Remove(index);

        }

    }

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

// CMPXCollectionCacheNode::GetChild

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

//

CMPXCollectionCacheNode* CMPXCollectionCacheNode::GetChild(

    TMPXItemId aId)

    {

    MPX_FUNC("CMPXCollectionCacheNode::GetChild");

    CMPXCollectionCacheNode* child(NULL);

    TInt index = IndexOfId(aId);

    if (index != KErrNotFound)

        {

        child = iChildren[index];

        }

    return child;

    }

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

// CMPXCollectionCacheNode::SetResultsL

// If results are already stored in the node try to merge the new results,

// otherwise overwrite them.

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

//

void CMPXCollectionCacheNode::SetResultsL(

    const TArray<TMPXAttribute>& aAttrs,

    CMPXMedia& aResults,

    TBool aMediaFromOpen )

    {

    MPX_FUNC("CMPXCollectionCacheNode::SetResultsL");

    // Problem if we did not have results from before, but

    // want to merge in new data. Plugins returning all results will

    // not contain KMPXCollectionOpenLResultRange in the media

    // therefore we do manual merging. If it does contain the attribute

    // That means it is from a subset, with a particular offset and block size

    //

    TMPXOpenDataBlock block;

    block.iOffset = KErrNotFound;

    if( aResults.IsSupported( KMPXCollectionOpenLResultRange ) )

        {

        block = aResults.ValueTObjectL<TMPXOpenDataBlock>( 

                                            KMPXCollectionOpenLResultRange );

        // If the results have not been cached before, 

        // we have nothing to merge

        //

        if( !iResults && block.iOffset != KErrNotFound )

            {

            User::Leave( KErrArgument );

            }

        }

    TBool overwrite(ETrue);

    // Merge

    if ( iResults )

        {

        // extract the arrays from the two media instances

        CMPXMediaArray* existingArray(NULL);

        if ( iResults->IsSupported(KMPXMediaArrayContents) )

            {

            existingArray = 

                        iResults->Value<CMPXMediaArray>(KMPXMediaArrayContents);

            User::LeaveIfNull(existingArray);

            }

        const CMPXMediaArray* newArray(NULL);

        if ( aResults.IsSupported( KMPXMediaArrayContents ))

            {

            newArray = aResults.Value<CMPXMediaArray>(KMPXMediaArrayContents);

            User::LeaveIfNull(const_cast<CMPXMediaArray*>(newArray));

            }

        // Only need to merge the two arrays if they exist, else it will just overwrite

        if ( existingArray && newArray && existingArray->Count())

            {

            if( block.iOffset == KErrNotFound )

                {

                overwrite = DoMergeMediaArraysL( *existingArray, 

                                                 *newArray );

                }

            else // aOffset != KErrNotFound 

                {

                DoInsertMediaArraysL( *existingArray, 

                                      *newArray, 

                                      block );

                // These 2 attributes already merged

                //

                aResults.Delete( KMPXMediaArrayContents );

                aResults.Delete( KMPXMediaArrayCount );

                // Merge container media

                //

                iResults->MergeMediaL( aResults );

                // Merge the root media

                //

                overwrite = EFalse;

                }

            }

        else

            {

            iResults->MergeMediaL( aResults );

            overwrite = EFalse;

            }

        }

    if (overwrite)

        {

        // List of supported attributes is 

        // seperated to media w/ container from OpenL()

        // and media only from MediaL()

        //

        if( aMediaFromOpen )

            {

            iAttrs.Reset();

            ::CopyArrayL(aAttrs, iAttrs);

            }

        else

            {

            iContainerAttrs.Reset();

            ::CopyArrayL(aAttrs, iContainerAttrs);

            }

        delete iResults;

        iResults = NULL;

        iResults = CMPXMedia::NewL( aResults );

        }

    else

        {

        // Update either the array list or the root media list

        //

        if( aMediaFromOpen )

            {

            // Add the attributes into the list

            for ( TInt attrIndex = 0; attrIndex < aAttrs.Count(); attrIndex++ )

                {

                const TMPXAttribute& attr = aAttrs[attrIndex];

                if ( !AttributeExists( attr, iAttrs ))

                    {

                    iAttrs.AppendL( attr );

                    }

                }    

            }

        else

            {

            // Add the attributes into the container list

            for ( TInt attrIndex = 0; attrIndex < aAttrs.Count(); attrIndex++ )

                {

                const TMPXAttribute& attr = aAttrs[attrIndex];

                if ( !AttributeExists( attr, iContainerAttrs ))

                    {

                    iContainerAttrs.AppendL( attr );

                    }

                }

            }

        }

#ifdef _DEBUG

    MPX_DEBUG1("CMPXCollectionCacheNode::SetResultsL(): Attributes cached");

    for ( TInt k = 0; k < iAttrs.Count(); k++ )

        {

        MPX_DEBUG4("CMPXCollectionCacheNode::SetResultsL(): attr[%d] = {0x%x,0x%x}", 

                   k, iAttrs[k].ContentId(), iAttrs[k].AttributeId());

        }

#endif

    }

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

// CMPXCollectionCacheNode::AttributesExist

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

//

TBool CMPXCollectionCacheNode::AttributesExist(

    const TArray<TMPXAttribute>& aAttrs)

    {

    MPX_FUNC("CMPXCollectionCacheNode::AttributesExist");

    TBool exist(ETrue);

    if (0 == aAttrs.Count())

        {

        // no attributes specified, always exist

        exist = ETrue;

        }

    else if (0 == iAttrs.Count())

        {

        // no existing attributes, always do not exist

        exist = EFalse;

        }

    else

        {

        // both have valid number of attributes

        TInt count(aAttrs.Count());

        for (TInt index = 0; index < count; ++index)

            {

            if (!AttributeExists(aAttrs[index], iAttrs))

                {

                exist = EFalse;

                break;

                }

            }

        }

    return exist;

    }

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

// CMPXCollectionCacheNode::AttributesExist

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

//

TBool CMPXCollectionCacheNode::ContainerAttributesExist(

    const TArray<TMPXAttribute>& aAttrs)

    {

    MPX_FUNC("CMPXCollectionCacheNode::ContainerAttributesExist");

    TBool exist(ETrue);

    if (0 == aAttrs.Count())

        {

        // no attributes specified, always exist

        exist = ETrue;

        }

    else if (0 == iContainerAttrs.Count())

        {

        // no existing attributes, always do not exist

        exist = EFalse;

        }

    else

        {

        // both have valid number of attributes

        TInt count(aAttrs.Count());

        for (TInt index = 0; index < count; ++index)

            {

            if (!AttributeExists(aAttrs[index], 

                                 iContainerAttrs))

                {

                exist = EFalse;

                break;