/*

* 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:  Part of SyncML Data Synchronization Plug In Adapter

*

*/

#include "changefinder.h"

#include "logger.h"

const TUint KSnapshotFormatVersion ( 0xf0000001 ); // format version

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

// CChangeFinder::NewL

// Static function to create CChangeFider object(s)

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

CChangeFinder* CChangeFinder::NewL( MSmlSyncRelationship& aSyncRelationship, TKeyArrayFix aKey,

        TBool& aHasHistory, TInt aStreamUid )

    {

    CChangeFinder* self = new (ELeave) CChangeFinder( aSyncRelationship, aKey, aStreamUid );

    CleanupStack::PushL( self );

    self->ConstructL( aHasHistory );

    CleanupStack::Pop( self );

    return self;

    }

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

// CChangeFinder::CChangeFinder

// Constructor for the class

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

CChangeFinder::CChangeFinder( MSmlSyncRelationship& aSyncRelationship, TKeyArrayFix aKey, TInt aStreamUid ) :

iSyncRelationship( aSyncRelationship ),

iKey( aKey ),

iStreamUid( aStreamUid ),

iDataStoreUid( KErrNotFound )

    {

    }

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

// CChangeFinder::~CChangeFinder

// Destructor for the class, closes the ChangeFinder and writes snapshot to stream

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

CChangeFinder::~CChangeFinder()

    {

    LOGGER_ENTERFN( "CChangeFinder::~CChangeFinder" );

    delete iOldSnapshot;

	delete iCurrentSnapshot;

    LOGGER_LEAVEFN( "CChangeFinder::~CChangeFinder" );

    }

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

// CChangeFinder::ConstructL

// 2nd phase constructor for the class, reads snapshot from stream

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

void CChangeFinder::ConstructL( TBool& aHasHistory )

    {

    LOGGER_ENTERFN( "CChangeFinder::ConstructL" );

    iOldSnapshot = new (ELeave) CSnapshotArray( KSnapshotGranularity );

	iCurrentSnapshot = new (ELeave) CSnapshotArray( KSnapshotGranularity );

    LOGGER_WRITE("CChangeFinder::ConstructL, CSnapshotArray:s created");

    TUid uid = {iStreamUid};

    aHasHistory = iSyncRelationship.IsStreamPresentL( uid );

    if ( aHasHistory )

        {

        LOGGER_WRITE("CChangeFinder::ConstructL, HasHistory");

        // Open stream for reading

        RReadStream readStream;

        iSyncRelationship.OpenReadStreamLC( readStream, uid );

        // Read used format version

        TUint formatVer = readStream.ReadUint32L();

        if ( formatVer != KSnapshotFormatVersion )

            {

            // Wrong version, do not try to import data

            LOGGER_WRITE("CChangeFinder::ConstructL, Wrong format version -> no history");

            aHasHistory = EFalse;

            CleanupStack::PopAndDestroy( &readStream );

            LOGGER_LEAVEFN("CChangeFinder::ConstructL");

            return;

            }

        else

            {

            LOGGER_WRITE("CChangeFinder::ConstructL, format is OK");

            }

        // Read item count

        TInt count = readStream.ReadUint32L();

        // Read items

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

            {

            TSnapshotItem item;

            item.InternalizeL( readStream );

            iOldSnapshot->InsertIsqL( item, iKey );

            }

        iOldSnapshot->Compress();

        LOGGER_WRITE_1("iOldSnapshot done, iOldSnapshot->Count: %d", iOldSnapshot->Count() );

        CleanupStack::PopAndDestroy( &readStream ); // readStream

        }

    else

        {

        LOGGER_WRITE("CChangeFinder::ConstructL, no sync history.");

        }

    LOGGER_LEAVEFN("CChangeFinder::ConstructL");

    }

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

// CChangeFinder::CloseL

// Closes ChangeFinder object and writes snapshot to stream

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

void CChangeFinder::CloseL()

    {

    LOGGER_ENTERFN( "CChangeFinder::CloseL" );

    RWriteStream writeStream;

    TUid uid = {iStreamUid};

    // Open write stream

    iSyncRelationship.OpenWriteStreamLC( writeStream, uid );

    // Write used format version

    writeStream.WriteUint32L( KSnapshotFormatVersion );

    // Write item count

    TInt count = iOldSnapshot->Count();

    writeStream.WriteUint32L( count );

    // Write items

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

        {

        const TSnapshotItem& item = iOldSnapshot->At( i );

        item.ExternalizeL( writeStream );

        }

    writeStream.CommitL();

    CleanupStack::PopAndDestroy( &writeStream ); // writeStream

    LOGGER_LEAVEFN( "CChangeFinder::CloseL" );

    }

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

// CChangeFinder::ResetL

// Resets synchronization history, all contetn is considered new after this call

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

void CChangeFinder::ResetL()

    {

    LOGGER_ENTERFN( "CChangeFinder::ResetL" );

    if ( iOldSnapshot )

        {

        LOGGER_WRITE("iOldSnapshot->Reset()");

        iOldSnapshot->Reset();

        }

    LOGGER_LEAVEFN( "CChangeFinder::ResetL" );

    }

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

// CChangeFinder::FindChangedItemsL

// Compares snapshots, finds changed items

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

void CChangeFinder::FindChangedItemsL( CNSmlDataItemUidSet& aChangedUids )

    {   

    LOGGER_ENTERFN( "CChangeFinder::FindChangedItemsL" );

    aChangedUids.Reset();

    if ( !iCurrentSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::FindChangedItemsL leaved, no current snapshot." );

        User::Leave( KErrNotFound );

        }

    if ( !iOldSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::FindChangedItemsL leaved, no old snapshot." );

        User::Leave( KErrNotFound );

        }

    TInt index;

    TInt count = iCurrentSnapshot->Count();

    LOGGER_WRITE_1( "CChangeFinder::FindChangedItemsL items on iCurrentSnapshot: %d", count );

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

        {

        const TSnapshotItem& currentItem = iCurrentSnapshot->At( i );

        // Find this entry from the old snapshot

        if ( iOldSnapshot->FindIsq( currentItem, iKey, index ) == KErrNone)

            {

            // This is the old item

            TSnapshotItem& oldItem = iOldSnapshot->At( index );

            if ( currentItem.Hash().Compare( oldItem.Hash() ) != 0 )

                {

                // add to list

				User::LeaveIfError( aChangedUids.AddItem( currentItem.ItemId() ) );

                }

            }

        }

    LOGGER_LEAVEFN( "CChangeFinder::FindChangedItemsL" );

    }

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

// CChangeFinder::FindDeletedItemsL

// Compares snapshots, finds deleted items

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

void CChangeFinder::FindDeletedItemsL( CNSmlDataItemUidSet& aDeletedUids )

    {

    LOGGER_ENTERFN( "CChangeFinder::FindDeletedItemsL" );

    aDeletedUids.Reset();

    if ( !iOldSnapshot )

        {

        LOGGER_LEAVEFN( "CChangeFinder::FindDeletedItemsL leaved, no old snapshot." );

        User::Leave( KErrNotFound );

        }

    TInt index;

    TInt count = iOldSnapshot->Count();

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

        {

        const TSnapshotItem& currentItem = iOldSnapshot->At( i );

        // If there's no current snapshot, this definately is deleted item

        if ( !iCurrentSnapshot )

            {

            User::LeaveIfError( aDeletedUids.AddItem( currentItem.ItemId() ) );

            LOGGER_WRITE_1( "Item %d was deleted.", currentItem.ItemId() );

            }

        // It is also new if it doesn't exist int the current snapshot.

        else if ( iCurrentSnapshot->FindIsq( currentItem, iKey, index ) != KErrNone )

            {

            User::LeaveIfError( aDeletedUids.AddItem( currentItem.ItemId() ) );

            LOGGER_WRITE_1( "Item %d was deleted.", currentItem.ItemId() );

            }       

        }

    LOGGER_LEAVEFN( "CChangeFinder::FindDeletedItemsL" );

    }

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

// CChangeFinder::FindNewItemsL

// Compares snapshots, finds new items

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

void CChangeFinder::FindNewItemsL( CNSmlDataItemUidSet& aNewUids )

    {

    LOGGER_ENTERFN( "CChangeFinder::FindNewItemsL" );

    aNewUids.Reset();

    /*if ( !iCurrentSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::FindNewItemsL leaved, no current snapshot." );

        User::Leave( KErrNotFound );

        }*/

    TInt index;

    TInt count = iCurrentSnapshot->Count();

    LOGGER_WRITE_1( "iCurrentSnapshot->Count(): %d", count );

    LOGGER_WRITE_1( "iOldSnapshot->Count(): %d", iOldSnapshot->Count() );

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

        {

        const TSnapshotItem& currentItem = iCurrentSnapshot->At( i );

        // If there's no old snapshot, all items are new

        if ( !iOldSnapshot )

            {

            User::LeaveIfError( aNewUids.AddItem( currentItem.ItemId() ) );

            LOGGER_WRITE_1( "!iOldSnapshot, Item %d was new.", currentItem.ItemId() );

            }

        // It is also new if it doesn't exist int the old snapshot.

        else if ( iOldSnapshot->FindIsq( currentItem, iKey, index ) != KErrNone )

            {

            User::LeaveIfError( aNewUids.AddItem( currentItem.ItemId() ) );

            LOGGER_WRITE_1( "Item %d was new.", currentItem.ItemId() );

            }       

        }

    LOGGER_LEAVEFN( "CChangeFinder::FindNewItemsL" );

    }

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

// CChangeFinder::FindMovedItemsL

// Compares snapshots, finds moved items

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

void CChangeFinder::FindMovedItemsL( CNSmlDataItemUidSet& aMovedUids )

    {

    LOGGER_ENTERFN( "CChangeFinder::FindMovedItemsL" );

    aMovedUids.Reset();

    if ( !iCurrentSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::FindMovedItemsL leaved, no current snapshot." );

        User::Leave( KErrNotFound );

        }

    if ( !iOldSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::FindMovedItemsL leaved, no old snapshot." );

        User::Leave( KErrNotFound );

        }

    TInt index;

    TInt count = iCurrentSnapshot->Count();

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

        {

        const TSnapshotItem& currentItem = iCurrentSnapshot->At( i );

        // Find this entry from the old snapshot

        if(iOldSnapshot->FindIsq( currentItem, iKey, index ) == KErrNone)

            {

            // This is the old item

            TSnapshotItem& oldItem = iOldSnapshot->At( index );

            // Report only moved items in which only parent id has been changed

            if ( oldItem.ParentId() != currentItem.ParentId()

                && currentItem.Hash().Compare( oldItem.Hash() ) == 0 )

                {

                User::LeaveIfError( aMovedUids.AddItem( currentItem.ItemId() ) );

                LOGGER_WRITE_1( "Item %d was moved.", currentItem.ItemId() );

                }

            }       

        }

    LOGGER_LEAVEFN( "CChangeFinder::FindMovedItemsL" );     

    }

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

// CChangeFinder::ItemAddedL

// Adds item to snapshot, this item is no longer considered new

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

void CChangeFinder::ItemAddedL( const TSnapshotItem& aItem )

    {

    LOGGER_ENTERFN( "CChangeFinder::ItemAddedL" );

    // Add this to old snapshot, if there's no old snapshot it must be created

    if ( !iOldSnapshot )

        {

        iOldSnapshot = new (ELeave) CSnapshotArray( KSnapshotGranularity );

        }

    LOGGER_WRITE_1( "Adding item %d.", aItem.ItemId() );

    iOldSnapshot->InsertIsqL( aItem, iKey );

    iOldSnapshot->Compress();

    LOGGER_LEAVEFN( "CChangeFinder::ItemAddedL" );

    }

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

// CChangeFinder::ItemDeletedL

// Removes item to snapshot, this item is no longer considered deleted

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

void CChangeFinder::ItemDeletedL( const TSnapshotItem& aItem )

    {

    LOGGER_ENTERFN( "CChangeFinder::ItemDeletedL" );

    LOGGER_WRITE_1( "deleting item %d.", aItem.ItemId() );

    if ( !iOldSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::ItemDeletedL leaved, no old snapshot." );

        User::Leave( KErrNotFound );

        }

    // Delete item from the old snapshot

    TInt index;

    if ( iOldSnapshot->FindIsq( aItem, iKey, index ) == KErrNone )

        {

        iOldSnapshot->Delete( index );

        }

    else // Skip, there wasn't such entry

        {

        LOGGER_WRITE( "iOldSnapshot->FindIsq, item was not found." );

        }  

    LOGGER_LEAVEFN( "CChangeFinder::ItemDeletedL" );

    }

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

// CChangeFinder::ItemUpdatedL

// Updates item to snapshot, this item is no longer considered changed

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

void CChangeFinder::ItemUpdatedL( const TSnapshotItem& aItem )

    {

    LOGGER_ENTERFN( "CChangeFinder::ItemUpdatedL" );

    LOGGER_WRITE_1( "Updating item %d.", aItem.ItemId() );

    // There must be such entry in the snapshot after this

    // If there isn't old snapshot, we'll create it and add the item

    if ( !iOldSnapshot )

        {

        iOldSnapshot = new (ELeave) CSnapshotArray( KSnapshotGranularity );

        ItemAddedL( aItem );

        }

    else

        {

        // Update item in the old snapshot

        TInt index;

        if ( iOldSnapshot->FindIsq( aItem, iKey, index ) == KErrNone )

            {

            iOldSnapshot->At( index ) = aItem;

            }

        else 

            {

            // There was old snapshot but no such item. Let's add it

            ItemAddedL( aItem );

            }

        }

    LOGGER_LEAVEFN( "CChangeFinder::ItemUpdatedL" );

    }

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

// CChangeFinder::ItemMovedL

// Moves item within snapshot, this item is no longer considered moved

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

void CChangeFinder::ItemMovedL( const TSnapshotItem& aItem )

    {

    LOGGER_ENTERFN( "CChangeFinder::ItemMovedL" );

    LOGGER_WRITE_1( "Moving item %d.", aItem.ItemId() );

    // There must be such entry in the snapshot after this

    // If there isn't old snapshot, we'll create it and add the item

    if ( !iOldSnapshot )

        {

        iOldSnapshot = new (ELeave) CSnapshotArray( KSnapshotGranularity );

        ItemAddedL( aItem );

        }

    else

        {

        // Update item's parent in the old snapshot

        TInt index;

        if ( iOldSnapshot->FindIsq( aItem, iKey, index ) == KErrNone )

            {

            iOldSnapshot->At(index) = aItem;

            }

        else 

            {

            // There was old snapshot but no such item. Let's add it

            ItemAddedL( aItem );

            }   

        }

    LOGGER_LEAVEFN("CChangeFinder::ItemMovedL");    

    }

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

// CChangeFinder::CommitChangesL

// Commits current changes to snapshot

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

void CChangeFinder::CommitChangesL()

    {

    LOGGER_ENTERFN( "CChangeFinder::CommitChangesL" );

    if ( !iCurrentSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::CommitChangesL leaved, current snapshot missing." );

        User::Leave( KErrNotFound );

        }

    if ( !iOldSnapshot )

        {

        iOldSnapshot = new (ELeave) CSnapshotArray( KSnapshotGranularity );

        }

    // Delete everything from the old snapshot

    iOldSnapshot->Reset();

    // Loop through all the items in current snapshot

    TInt count = iCurrentSnapshot->Count();

    // Copy everything from current to old snapshot

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

        {

        // Commit it to the old array.

        iOldSnapshot->InsertIsqL( iCurrentSnapshot->At( i ), iKey );

        }

    LOGGER_LEAVEFN( "CChangeFinder::CommitChangesL" );

    }

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

// CChangeFinder::CommitChangesL

// Commits current changes to snapshot, affects only a specified group of items

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

void CChangeFinder::CommitChangesL( const MSmlDataItemUidSet& aUids )

    {

    LOGGER_ENTERFN( "CChangeFinder::CommitChangesL" );

    // This function commits changes from current snapshot to old snapshot

    // But commits only the entries in the parameter array

    if ( !iCurrentSnapshot )

        {

        LOGGER_WRITE( "CChangeFinder::CommitChangesL leaved, current snapshot missing." );

        User::Leave( KErrNotFound );

        }

    if ( !iOldSnapshot )

        {

        iOldSnapshot = new (ELeave) CSnapshotArray( KSnapshotGranularity );

        }

    for ( TInt i = 0; i < aUids.ItemCount(); i++ )

		{

		TSmlDbItemUid itemId = aUids.ItemAt( i );

		TSnapshotItem temp( itemId );

		TInt indexOld( -1 );

		TInt indexNew( -1 );

		if ( !iOldSnapshot->FindIsq( temp, iKey, indexOld) )

			{

			if ( !iCurrentSnapshot->FindIsq(temp, iKey, indexNew) )

				{