/*

* 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:  

*

*/

#ifndef C_NCDNODESEENINFO_H

#define C_NCDNODESEENINFO_H

#include <e32base.h>

#include "ncdstoragedataitem.h"

#include "ncdnodefactory.h"

// Defines the maximum amount of "new" idenfifiers. If

// this value is exceeded then older identifiers will be

// removed from the bottom of the "new" list.

const TInt KNewListMaxSize(50);

class CNcdNodeIdentifier;

class MNcdStorageManager;

class CNcdNodeManager;

class CNcdNodeFolder;

class CNcdChildEntity;

class CNcdChildEntityMap;

class CNcdGeneralManager;

enum TNcdNewStatus

    {

    /** Node itself is new */

    ENcdStatusNew = 0x00000001,

    /** Node itself is new */

    ENcdStatusNewButSeen = 0x00000010,

    /** Folder contains new items */

    ENcdStatusNewNodesInside = 0x00000100

    };

/**

 * Stores information about new nodes.

 */

class CNcdNodeSeenInfo : public CBase

    {

public:

    static CNcdNodeSeenInfo* NewL( CNcdGeneralManager& aGeneralManager );

    static CNcdNodeSeenInfo* NewLC( CNcdGeneralManager& aGeneralManager );

    ~CNcdNodeSeenInfo();

    /**

     * Adds a structure identifier to the new list if it does not exist yet.

     * If it does exist, it will be moved to the top of the list.

     *

     * @param aStructureIdentifier The identifier.

     * @param aNewStatus New status of the node.

     */

    void AddNewIdL( const CNcdNodeIdentifier& aStructureIdentifier,

        TNcdNewStatus aNewStatus, CNcdNodeFactory::TNcdNodeType aNodeType );

    void AddNewIdL( const CNcdChildEntity& aChildEntity );

    /**

     * Tells whether the given structure node is seen.

     *

     * @param aStructureIdentifier The structure node identifier.

     * @return ETrue if the node is seen, otherwise EFalse.

     */

    TBool IsSeenL( const CNcdNodeIdentifier& aStructureIdentifier );

    /**

     * Sets the given structure node as seen. Affects only after

     * CommitChangesL.

     *

     * @param aStructureIdentifier The structure node identifier.

     */

    void SetSeenL( const CNcdNodeIdentifier& aStructureIdentifier );

    /**

     * Checks the new statuses of a folder's children against the previous children.

     * The folder's and it's parent hierarchy's new statuses are set if needed.

     * The previous array is fetched from the folder.

     *

     * @param aParentFolder The parent folder to check.

     */

    void CheckFolderNewStatusL( CNcdNodeFolder& aParentFolder );

    /**

     * Checks the new statuses of a folder's children against the previous children.

     * The folder's and it's parent hierarchy's new statuses are set if needed.

     * The previous array is fetched from the folder.

     *

     * @param aParentFolder The parent folder to check.

     * @param aPreviousChildArray The previous children to check against.

     */

    void CheckFolderNewStatusL(  CNcdNodeFolder& aParentFolder,

        const RPointerArray<CNcdChildEntity>& aPreviousChildArray );

    /**

     * Checks the new status of a child node against the parent folder's

     * previous children. The parent hierarchy's new statuses are set if needed.

     *

     * @param aParentFolder The parent folder of the node.

     * @param aChildIndex The index of the child node to check.

     */

    void CheckChildNewStatusL( CNcdNodeFolder& aParentFolder, TInt aChildIndex );

    /**

     * Clears the new list completely.

     *

     * @param aClient Uid of the client whose list will be cleared.

     */

    void ClearInfoL( const TUid& aClientUid );

    /**

     * Commits the changes made by SetSeenL (the seen nodes are be removed from the new list)

     * and saves seen info to the database storage.

     *

     * @param aClient Uid of the client whose changes are committed.

     */

    void CommitChangesL( const TUid& aClientUid );

     /**

     * Creates lists of previous children for the children of the given folder.

     *

     * @note Only folders with type CNcdNodeFactory::ENcdNodeFolder are handled

     * (e.g. bundles are not handled).

     * @param aParentFolder The folder.

     * @param aChildEntityMaps Will contain a child entity map for each child on return.

     */

    void CreatePreviousListsForChildrenL( CNcdNodeFolder& aParentFolder,

        RPointerArray<CNcdChildEntityMap>& aChildEntityMaps );

    /**

     * Stoeres previous child lists for the existing child folders of the given folder.

     *

     * @param aParentFolder The folder.

     * @param aChildEntityMaps Child entity maps containing the previous lists.

     */

    void StorePreviousListsToExistingChildrenL( CNcdNodeFolder& aParentFolder,

        const RPointerArray<CNcdChildEntityMap>& aChildEntityMaps );

    /**

     * Does a new status check for the transparent children of the given folder.

     *

     * @param aParentFolder The folder.

     */

    void DoNewCheckForTransparentChildrenL( CNcdNodeFolder& aParentFolder );

    /**

     * Immediately removes new id for the folder if no new children exist.

     */

    void RefreshFolderSeenStatusL( const CNcdNodeIdentifier& aNodeIdentifier );

private:

    class CClientSeenInfo;

    class CNcdNodeNewStatus;

    CNcdNodeSeenInfo( CNcdGeneralManager& aGeneralManager );

    void ConstructL();

    /**

     * Returns the client's client info, if one exists.

     *

     * @param aClientUid The uid of the client.

     * @return The client info, or NULL. Ownership is not transferred.

     */

    CClientSeenInfo* ClientInfo( const TUid& aClientUid ) const;

    /**

     * Checks that is the given identifier in the new status array.

     *

     * @param aNodeIdentifier The identifier to search for.

     * @return The index of the given identifier in the array if found,

     * otherwise KErrNotFound.

     */

    TInt IndexInNewStatusArray( const CNcdNodeIdentifier& aNodeIdentifier ) const;

    /**

     * Getter for node new status.

     *

     * @param aNodeIdentifier The identifier to search for.

     * @return New status for the node, NULL if not found.

     */

    CNcdNodeNewStatus* NodeNewStatus( const CNcdNodeIdentifier& aNodeIdentifier );

    TInt IndexInSeenArray( const CNcdNodeIdentifier& aNodeIdentifier ) const;    

    TBool IsAddedAsSeen( const CNcdNodeIdentifier& aNodeIdentifier ) const;

    void RemoveFromSeenListL( const CNcdNodeIdentifier& aNodeIdentifier );

    void RemoveFromNewListL( const CNcdNodeIdentifier& aNodeIdentifier );

    TBool IsClientInfoLoaded( const TUid& aClientUid ) const;

    void RemoveClientInfo( const TUid& aClientUid );

    void DbLoadClientInfoL( const TUid& aClientUid );

    void DbSaveClientInfoL( const TUid& aClientUid );

    /**

     * Removes the given structure identifier from the new list.

     *

     * @param aStructureIdentifier The structure node identifier.

     */    

    void RemoveNewIdL( const CNcdNodeIdentifier& aStructureIdentifier );

    /**

     * Checks that does the given child entity exist in the given array.

     * Comparison is done with identifier only.

     *

     * @param aChildEntity The child to search for.

     * @param aChildArray The array to search from.

     * @param aNodeWithSameIndexFound Set to ETrue if there is a

     * node in aChildArray with the same index as aChildEntity has. NOTE:

     * Since this is not needed if node is found the searching will stop and

     * this value may not have been set correctly! Only use if node not found!

     * @return ETrue if a child with the same identifier is found in the array.

     */

    TBool ChildExistsInArrayL( const CNcdChildEntity& aChildEntity,

        const RPointerArray<CNcdChildEntity>& aChildArray,

        TBool& aNodeWithSameIndexFound );

    /**

     * Checks whether a folder has new children that are have not been set seen.

     * Check is made against current new list only, no comparison against

     * previous child array is made.

     */

    TBool FolderHasNewUnseenChildrenL( const CNcdNodeIdentifier& aNodeIdentifier );

    /**

     * Checks whether a folder has new children. Being set seen has no effect here.

     * Check is made against current new list only, no comparison against

     * previous child array is made.

     */

    TBool FolderHasNewChildrenL( const CNcdNodeIdentifier& aNodeIdentifier );

    /**

     * Adds a seen id.

     */

    void AddSeenIdL( const CNcdNodeIdentifier& aNodeIdentifier );

    /**

     * Sets a folder seen if it no longer has new child items.

     */

    void SetFolderSeenIfNeededL( const CNcdNodeIdentifier& aNodeIdentifier );

    /**

     * Sets all children of the folder new.

     */

    void SetChildrenNewL( CNcdNodeFolder& aParentFolder );

private:

    class CClientSeenInfo : public CBase,

                            public MNcdStorageDataItem

        {

    public:

        CClientSeenInfo( const TUid& aClientUid );

        ~CClientSeenInfo();

    public: // from MNcdStorageDataItem

        /* 

        * @see MNcdStorageDataItem::ExternalizeL

        */

        virtual void ExternalizeL( RWriteStream& aStream );

        /* 

        * @see MNcdStorageDataItem::InternalizeL

        */

        virtual void InternalizeL( RReadStream& aStream );

    public: // member variables

        // List of node new statuses.

        RPointerArray<CNcdNodeNewStatus> iNodeNewStatusArray;

        // List of seen nodes.

        RPointerArray<CNcdNodeIdentifier> iSeenStructureIds;

        TUid iClientUid;

        };

    /**

     * Node new status.

     */

    class CNcdNodeNewStatus : public CBase

        {

    public:

        static CNcdNodeNewStatus* NewL( const CNcdNodeIdentifier& aNodeIdentifier,

            TNcdNewStatus aNewStatus, CNcdNodeFactory::TNcdNodeType aNodeType );

        static CNcdNodeNewStatus* NewLC( const CNcdNodeIdentifier& aNodeIdentifier,

            TNcdNewStatus aNewStatus, CNcdNodeFactory::TNcdNodeType iNodeType );

        static CNcdNodeNewStatus* NewL( RReadStream& aReadStream );

        static CNcdNodeNewStatus* NewLC( RReadStream& aReadStream );

        ~CNcdNodeNewStatus();

    public:

        const CNcdNodeIdentifier& Identifier() const;

        TNcdNewStatus NewStatus() const;

        void SetNewStatus( TNcdNewStatus aNewStatus );

        CNcdNodeFactory::TNcdNodeType NodeType() const;

        void ExternalizeL( RWriteStream& aStream );

        void InternalizeL( RReadStream& aStream );

    private:

        CNcdNodeNewStatus( TNcdNewStatus aNewStatus,

            CNcdNodeFactory::TNcdNodeType aNodeType );

        CNcdNodeNewStatus();

        void ConstructL( const CNcdNodeIdentifier& aNodeIdentifier );

    private: //Data

        CNcdNodeIdentifier* iNodeIdentifier;

        TNcdNewStatus iNewStatus;

        CNcdNodeFactory::TNcdNodeType iNodeType;

        };

    CNcdGeneralManager& iGeneralManager;

    RPointerArray<CClientSeenInfo> iClientSeenInfos;

    // Storage manager.

    MNcdStorageManager& iStorageManager;

    // Node manager.

    CNcdNodeManager& iNodeManager;       

    };

#endif // C_NCDNODESEENINFO_H