/*

* 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 "ncdnodeseeninfo.h"

#include "ncdnodeidentifierutils.h"

#include "ncdnodeidentifier.h"

#include "ncdstorage.h"

#include "ncdstoragemanager.h"

#include "ncdproviderdefines.h"

#include "ncddatabasestorage.h"

#include "ncdstorageitem.h"

#include "ncdrootnode.h"

#include "ncdnodeidentifiereditor.h"

#include "catalogsutils.h"

#include "ncdchildentity.h"

#include "ncdchildentitymap.h"

#include "ncdnodefolderlink.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

CNcdNodeSeenInfo* CNcdNodeSeenInfo::NewL( CNcdGeneralManager& aGeneralManager )

    {

    CNcdNodeSeenInfo* self = NewLC( aGeneralManager );

    CleanupStack::Pop( self );

    return self;

    }

CNcdNodeSeenInfo* CNcdNodeSeenInfo::NewLC( CNcdGeneralManager& aGeneralManager )

    {

    CNcdNodeSeenInfo* self = new( ELeave ) CNcdNodeSeenInfo( aGeneralManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CNcdNodeSeenInfo::CNcdNodeSeenInfo( CNcdGeneralManager& aGeneralManager ) :

    iGeneralManager( aGeneralManager ),

    iStorageManager( aGeneralManager.StorageManager() ), 

    iNodeManager( aGeneralManager.NodeManager() )

    {	

    }    

void CNcdNodeSeenInfo::ConstructL()

    {

    }    

CNcdNodeSeenInfo::~CNcdNodeSeenInfo()

    {

    DLTRACEIN((""));

    iClientSeenInfos.ResetAndDestroy();

    }

void CNcdNodeSeenInfo::AddNewIdL( const CNcdChildEntity& aChildEntity )

    {

    DLTRACEIN((""));

    AddNewIdL( aChildEntity.Identifier(), ENcdStatusNew, aChildEntity.NodeType() );

    }

void CNcdNodeSeenInfo::AddNewIdL( const CNcdNodeIdentifier& aNodeIdentifier,

    TNcdNewStatus aNewStatus, CNcdNodeFactory::TNcdNodeType aNodeType )

    {

    DLTRACEIN((""));

    const TUid& clientUid = aNodeIdentifier.ClientUid();

    if ( !IsClientInfoLoaded( clientUid ) ) 

        {

        DbLoadClientInfoL( clientUid );

        }

    CClientSeenInfo* info = ClientInfo( clientUid );

    DASSERT( info );

#ifdef CATALOGS_BUILD_CONFIG_DEBUG

    DLINFO(("New status array:"));

    for( TInt i = 0 ; i < info->iNodeNewStatusArray.Count() ; i++ )

        {

        DLINFO((_L("index: %d, id: %S"),i, &info->iNodeNewStatusArray[i]->Identifier().NodeId() ));

        }

#endif

    // Latest "new" nodes will be added to the top of the list and older "new" nodes will

    // drop out when max size is exceeded.

    TInt index = IndexInNewStatusArray( aNodeIdentifier );

    if( index == KErrNotFound )

        {

        DLTRACE(("Not found, create new."));

        // Create new status.

        CNcdNodeNewStatus* nodeNewStatus = CNcdNodeNewStatus::NewLC(

            aNodeIdentifier,

            aNewStatus,

            aNodeType );

        // Insert to the top of the list.

        info->iNodeNewStatusArray.InsertL( nodeNewStatus, 0 );

        CleanupStack::Pop( nodeNewStatus );

        }

    else

        {

        DLTRACE(("Found, update."));

        // Node is already in the new list -> move it to the top of the list.

        CNcdNodeNewStatus* nodeNewStatus = info->iNodeNewStatusArray[index];

        info->iNodeNewStatusArray.InsertL( nodeNewStatus, 0 );

        info->iNodeNewStatusArray.Remove( index + 1 );

        // Remove seen status if any

        RemoveFromSeenListL( aNodeIdentifier );

        // Update new status.

        nodeNewStatus->SetNewStatus( TNcdNewStatus(nodeNewStatus->NewStatus() | aNewStatus) );

        }

    // Set parent new as well.

    if( !NcdNodeIdentifierEditor::IdentifiesSomeRoot( aNodeIdentifier ) )

        {

        CNcdNodeIdentifier* parent = NcdNodeIdentifierEditor::ParentOfLC( aNodeIdentifier );

        AddNewIdL( *parent, ENcdStatusNewNodesInside, CNcdNodeFactory::ENcdNodeFolder );

        CleanupStack::PopAndDestroy( parent );

        }

    // Remove identifiers from the bottom if max size is exceeded.

    while( info->iNodeNewStatusArray.Count() > KNewListMaxSize )

        {

        delete info->iNodeNewStatusArray[info->iNodeNewStatusArray.Count() - 1];

        info->iNodeNewStatusArray.Remove(

            info->iNodeNewStatusArray.Count() - 1 );

        }

#ifdef CATALOGS_BUILD_CONFIG_DEBUG

    DLINFO(("New status array:"));

    for( TInt i = 0 ; i < info->iNodeNewStatusArray.Count() ; i++ )

        {

        DLINFO((_L("index: %d, id: %S"),i, &info->iNodeNewStatusArray[i]->Identifier().NodeId() ));

        }

#endif

    }

TBool CNcdNodeSeenInfo::IsSeenL( const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((_L("ns: %S, id: %S"), &aNodeIdentifier.NodeNameSpace(), &aNodeIdentifier.NodeId()));

    const TUid& clientUid = aNodeIdentifier.ClientUid();

    if ( !IsClientInfoLoaded( clientUid ) )

        {

        DbLoadClientInfoL( clientUid );

        }

    CClientSeenInfo* clientInfo = ClientInfo( aNodeIdentifier.ClientUid() );

    DASSERT( clientInfo );

    DLINFO((("clientInfo-ptr: %x"), clientInfo ));    

    DLINFO(("new count: %d", clientInfo->iNodeNewStatusArray.Count() ));

    TInt index = IndexInNewStatusArray( aNodeIdentifier );

    DLINFO(("index in new status array: %d", index ));

    return index == KErrNotFound;

    }

TBool CNcdNodeSeenInfo::ChildExistsInArrayL( const CNcdChildEntity& aChildEntity,

        const RPointerArray<CNcdChildEntity>& aChildArray,

        TBool& aNodeWithSameIndexFound )

    {

    DLTRACEIN((""));

    TBool childFound = EFalse;

    aNodeWithSameIndexFound = EFalse;

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

        {

        if( aChildArray[i]->Identifier().Equals( aChildEntity.Identifier() ) )

            {

            childFound = ETrue;

            }

        if( aChildArray[i]->Index() == aChildEntity.Index() )

            {

            aNodeWithSameIndexFound = ETrue;

            }

        }

    DLINFO(("childFound %d, aNodeWithSameIndexFound: %d", childFound,

        aNodeWithSameIndexFound));

    return childFound;

    }

void CNcdNodeSeenInfo::RefreshFolderSeenStatusL( 

    const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((_L("aNodeIdentifier: %S"), &aNodeIdentifier.NodeId() ));

    const TUid& clientUid = aNodeIdentifier.ClientUid();

    if ( !IsClientInfoLoaded( clientUid ) ) 

        {

        DbLoadClientInfoL( clientUid );

        }

    CClientSeenInfo* info = ClientInfo( clientUid );

    DASSERT( info );

    TInt index = IndexInNewStatusArray( aNodeIdentifier );

    if( index == KErrNotFound )

        {

        DLTRACE(("Not in new status array"));

        return;

        }

    if( !FolderHasNewChildrenL( aNodeIdentifier ) )

        {

        CNcdNodeNewStatus* newStatus = info->iNodeNewStatusArray[index];

        // Don't touch folders that are really new, only folders that have just

        // new items inside.

        if( !( newStatus->NewStatus() & ENcdStatusNew ||

               newStatus->NewStatus() & ENcdStatusNewButSeen ) )

            {

            // Special case: all new children have been removed, immediately remove folder's new status

            // (better user experience when compared to just setting it seen)

            RemoveFromNewListL( aNodeIdentifier );

            RemoveFromSeenListL( aNodeIdentifier );

            // Check parent as well.

            if( !NcdNodeIdentifierEditor::IdentifiesSomeRoot( aNodeIdentifier ) )

                {

                CNcdNodeIdentifier* parent = NcdNodeIdentifierEditor::ParentOfLC( aNodeIdentifier );

                RefreshFolderSeenStatusL( *parent );

                CleanupStack::PopAndDestroy( parent );

                }

            }

        }

    }

void CNcdNodeSeenInfo::SetFolderSeenIfNeededL( 

    const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((""));

    TInt index = IndexInNewStatusArray( aNodeIdentifier );

    if( index == KErrNotFound || IsAddedAsSeen( aNodeIdentifier ) )

        {

        DLTRACE(("Not in new status array, or already set seen"));

        return;

        }

    if( !FolderHasNewUnseenChildrenL( aNodeIdentifier ) )

        {

        // Add to seen list.

        AddSeenIdL( aNodeIdentifier );

        // Check parent as well.

        if( !NcdNodeIdentifierEditor::IdentifiesSomeRoot( aNodeIdentifier ) )

            {

            CNcdNodeIdentifier* parent = NcdNodeIdentifierEditor::ParentOfLC( aNodeIdentifier );

            SetFolderSeenIfNeededL( *parent );

            CleanupStack::PopAndDestroy( parent );

            }

        }

    }

TBool CNcdNodeSeenInfo::FolderHasNewUnseenChildrenL(

    const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((""));    

    CNcdNodeFolder& folder = iNodeManager.FolderL( aNodeIdentifier );

    const RPointerArray<CNcdChildEntity>& childArray = folder.ChildArray();

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

        {

        // NOTE: Children that are set seen are not considered new here.

        CNcdNodeNewStatus* nodeNewStatus = NodeNewStatus( childArray[i]->Identifier() );

        if( nodeNewStatus && !IsAddedAsSeen( childArray[i]->Identifier() ) )

            {

            DLTRACE(("New child found"));

            return ETrue;

            }

        }

    return EFalse;

    }

 TBool CNcdNodeSeenInfo::FolderHasNewChildrenL(

    const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((""));    

    CNcdNodeFolder& folder = iNodeManager.FolderL( aNodeIdentifier );

    const RPointerArray<CNcdChildEntity>& childArray = folder.ChildArray();

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

        {

        // NOTE: Children that are set seen are considered new here.

        CNcdNodeNewStatus* nodeNewStatus = NodeNewStatus( childArray[i]->Identifier() );

        if( nodeNewStatus )

            {

            DLTRACE(("New child found"));

            return ETrue;

            }

        }

    return EFalse;

    }

void CNcdNodeSeenInfo::AddSeenIdL( const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((""));

    CClientSeenInfo* info = ClientInfo( aNodeIdentifier.ClientUid() );

    DASSERT( info );

    // Add to seen list.

    CNcdNodeIdentifier* copy = CNcdNodeIdentifier::NewLC( aNodeIdentifier );

    info->iSeenStructureIds.AppendL( copy );

    CleanupStack::Pop( copy );

    }

void CNcdNodeSeenInfo::SetSeenL( const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((""));

    const TUid& clientUid = aNodeIdentifier.ClientUid();

    if ( !IsClientInfoLoaded( clientUid ) ) 

        {

        DbLoadClientInfoL( clientUid );

        }

    TInt index = IndexInNewStatusArray( aNodeIdentifier );

    if( index == KErrNotFound || IsAddedAsSeen( aNodeIdentifier ) )

        {

        DLTRACE(("Not in new status array, or already set seen"));

        return;

        }

    CClientSeenInfo* info = ClientInfo( clientUid );

    DASSERT( info );

    CNcdNodeNewStatus* nodeNewStatus = info->iNodeNewStatusArray[index];

    if( nodeNewStatus->NodeType() == CNcdNodeFactory::ENcdNodeItem )

        {

        AddSeenIdL( aNodeIdentifier );

        }

    else if ( nodeNewStatus->NewStatus() & ENcdStatusNew &&

        nodeNewStatus->NewStatus() & ENcdStatusNewNodesInside )

        {

        nodeNewStatus->SetNewStatus(

            TNcdNewStatus( ENcdStatusNewButSeen | ENcdStatusNewNodesInside ) );

        }

    else if ( nodeNewStatus->NewStatus() & ENcdStatusNew )

        {

        AddSeenIdL( aNodeIdentifier );

        }

    if( !NcdNodeIdentifierEditor::IdentifiesSomeRoot( aNodeIdentifier ) )

        {

        CNcdNodeIdentifier* parent = NcdNodeIdentifierEditor::ParentOfLC( aNodeIdentifier );

        SetFolderSeenIfNeededL( *parent );

        CleanupStack::PopAndDestroy( parent );

        }

    }

void CNcdNodeSeenInfo::CheckFolderNewStatusL( CNcdNodeFolder& aParentFolder )

    {

    DLTRACEIN((""));

    // New checking for children can only be done if the previous

    // child array has been stored. (Not stored e.g. on first time browse and

    // after restart)

    if( aParentFolder.PreviousChildCount() != KErrNotFound )

        {

        DLTRACE(("Previous children set -> do new comparison"));

        const RPointerArray<CNcdChildEntity>& previousChildArray =

            aParentFolder.PreviousChildArray();

        CheckFolderNewStatusL( aParentFolder, previousChildArray );

        }

    }

void CNcdNodeSeenInfo::CheckFolderNewStatusL( CNcdNodeFolder& aParentFolder,

    const RPointerArray<CNcdChildEntity>& aPreviousChildArray )

    {

    const TUid& clientUid = aParentFolder.Identifier().ClientUid();

    if ( !IsClientInfoLoaded( clientUid ) ) 

        {

        DbLoadClientInfoL( clientUid );

        }

    CClientSeenInfo* info = ClientInfo( clientUid );

    DASSERT( info );

    // This flag is used to determine whether this folder contains any new items.

    TBool newChildrenFound = EFalse;

    // Check new array against the previous array

    const RPointerArray<CNcdChildEntity>& childArray =

        aParentFolder.ChildArray();

    CNcdNodeNewStatus* parentNewStatus = NodeNewStatus( aParentFolder.Identifier() );

    TBool parentIsNew = parentNewStatus &&

            ( parentNewStatus->NewStatus() & ENcdStatusNew ||

              parentNewStatus->NewStatus() & ENcdStatusNewButSeen );

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

        {

        // compare with previous list

        TBool nodeWithSameIndexFound = EFalse;

        TBool childFound = ChildExistsInArrayL( *childArray[i],

            aPreviousChildArray,

            nodeWithSameIndexFound );

        if( parentIsNew )

            {

            DLTRACE(("Parent folder is new -> all children are new "));

            AddNewIdL( *childArray[i] );

            newChildrenFound = ETrue;

            }

        // if found -> old

        else if( childFound )

            {

            DLTRACE(("Child found -> old"));

            }

        // if not found && index < old child count && no node with this index in previous list

        //      -> old ( cannot know whether this is new or old so default to old, special case! )

        else if( !childFound

            && childArray[i]->Index() < aParentFolder.PreviousChildCount()

            && !nodeWithSameIndexFound )

            {

            DLTRACE(("Child not found and index < previous child count && node with same index not found -> default to old"));

            }

        // if not found && index < old child count && node exists with this index in previous list

        //      -> new ( the "usual" new case )

        else if( !childFound

             && childArray[i]->Index() < aParentFolder.PreviousChildCount()

             && nodeWithSameIndexFound )

            {

            DLTRACE(("New"));

            AddNewIdL( *childArray[i] );

            newChildrenFound = ETrue;

            }

        // if not found && index > old child count -> new 

        else if( !childFound

            && childArray[i]->Index() >= aParentFolder.PreviousChildCount() )

            {

            DLTRACE(("New"));

            AddNewIdL( *childArray[i] );

            newChildrenFound = ETrue;

            }

        // If no new children are found before, check that is this node previously new

        if( !newChildrenFound )

            {

            DLTRACE(("Check if already set new"));

            // Must be in new array and not in seen array to be new

            // (internally new, i.e. new even after commit).

            CNcdNodeNewStatus* nodeNewStatus = NodeNewStatus(

                childArray[i]->Identifier() );

            if( nodeNewStatus )

                {

                newChildrenFound = ETrue;

                }

            }

        }

    if( !newChildrenFound && parentIsNew )

        {

        // Special case: all new items have been removed, immediately remove parent's new status

        // (better user experience when compared to just setting it seen)

        RemoveFromNewListL( aParentFolder.Identifier() );

        }

    }   

void CNcdNodeSeenInfo::CheckChildNewStatusL( CNcdNodeFolder& aParentFolder,

    TInt aChildIndex )

    {

    DLTRACEIN((""));

    const TUid& clientUid = aParentFolder.Identifier().ClientUid();

    if ( !IsClientInfoLoaded( clientUid ) ) 

        {

        DbLoadClientInfoL( clientUid );

        }

    CNcdNodeNewStatus* parentNewStatus = NodeNewStatus( aParentFolder.Identifier() );

    TBool parentIsNew = parentNewStatus &&

            ( parentNewStatus->NewStatus() & ENcdStatusNew ||

              parentNewStatus->NewStatus() & ENcdStatusNewButSeen );

    if( parentIsNew )

        {

        DLTRACE(("Parent is new, set child new as well"));

        AddNewIdL( aParentFolder.ChildEntityByServerIndexL( aChildIndex ) );

        }

    else if( aParentFolder.PreviousChildCount() != KErrNotFound )

        {

        DLTRACE(("Previous child list set, do comparison."));

        const CNcdChildEntity& child = aParentFolder.ChildEntityByServerIndexL( aChildIndex );

        // compare with previous list

        TBool nodeWithSameIndexFound = EFalse;

        TBool childFound = ChildExistsInArrayL( child,

            aParentFolder.PreviousChildArray(),

            nodeWithSameIndexFound );

        // if found -> old

        if( childFound )

            {

            DLTRACE(("Child found -> old"));

            }

        // if not found && index < old child count && no node with this index in previous list

        //      -> old ( cannot know whether this is new or old so default to old, special case! )

        else if( !childFound

            && child.Index() < aParentFolder.PreviousChildCount()

            && !nodeWithSameIndexFound )

            {

            DLTRACE(("Child not found and index < previous child count && node with same index not found -> default to old"));

            }

        // if not found && index < old child count && node exists with this index in previous list

        //      -> new ( the "usual" new case )

        else if( !childFound

             && child.Index() < aParentFolder.PreviousChildCount()

             && nodeWithSameIndexFound )

            {

            DLTRACE(("New"));

            AddNewIdL( child );

            }

        // if not found && index > old child count -> new 

        else if( !childFound

            && child.Index() >= aParentFolder.PreviousChildCount() )

            {

            DLTRACE(("New"));