/*

* Copyright (c) 2005-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:  Part of SyncML Data Synchronization Plug In Adapter

*

*/

#include <sysutil.h> 

#include <favouritesitem.h>

#include <favouritesitemlist.h> 

#include <feedsserverclient.h>

#include <feedsserverfeed.h>

#include <feedsserverfolderitem.h>

#include "bookmarkdatastore.h"

#include "vbookmarkconverter.h"

#include "omadsfolderobject.h"

#include "bookmarkdataproviderdefs.h"

#include "conversionutil.h"

#include "changefinder.h"

#include "logger.h"

_LIT8( KBookmarkFolderMimeType, "application/vnd.omads-folder+xml" );

_LIT8( KBookmarkFolderMimeVersion, "" );

_LIT8( KBookmarkItemMimeType, "text/x-vbookmark" );

_LIT8( KBookmarkItemMimeVersion, "" );

_LIT( KRSSRootFolderName, "Web Feeds" );

const TInt KDefaultBufferSize = 1024;

const TInt KDataBufferNotReady = -1;

const TInt KRssFeedsOffset = 50000;

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

// CBookmarkDataStore::CBookmarkDataStore

// C++ default constructor can NOT contain any code, that might leave.

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

CBookmarkDataStore::CBookmarkDataStore() :

    iDataBaseOpened( EFalse ), iFeedsServer(*this), iRootFolder(*this),

    iKey( TKeyArrayFix( _FOFF( TNSmlSnapshotItem, ItemId() ), ECmpTInt ) ),

    iHasHistory( EFalse )

    {

    LOGGER_ENTERFN( "CBookmarkDataStore" );

    LOGGER_LEAVEFN( "CBookmarkDataStore" ); 

    }

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

// CBookmarkDataStore::ConstructL

// Symbian 2nd phase constructor, can leave.

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

void CBookmarkDataStore::ConstructL()

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::ConstructL" );

    User::LeaveIfError( iRfs.Connect() );

    User::LeaveIfError( iSession.Connect() );

    iNewItems = new ( ELeave ) CNSmlDataItemUidSet;

    iDeletedItems = new ( ELeave ) CNSmlDataItemUidSet;

    iSoftDeletedItems = new ( ELeave ) CNSmlDataItemUidSet;

    iUpdatedItems = new ( ELeave ) CNSmlDataItemUidSet;

    iMovedItems = new ( ELeave ) CNSmlDataItemUidSet;

    LOGGER_LEAVEFN( "CBookmarkDataStore::ConstructL" );

    }

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

// CBookmarkDataStore::~CBookmarkDataStore

// Destructor

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

CBookmarkDataStore::~CBookmarkDataStore()

    {

    LOGGER_ENTERFN( "~CBookmarkDataStore" );

    delete iDataBuffer;

    delete iNewItems;

    delete iDeletedItems;

    delete iSoftDeletedItems;

    delete iUpdatedItems;

    delete iMovedItems;

    delete iItemToBeReplaced;

    if ( iChangeFinder )

        {

        TRAPD( error, iChangeFinder->CloseL() );

        if ( error != KErrNone )

            {

            LOGGER_WRITE_1( "iChangeFinder->CloseL() leaved with %d", error );

            }

        }

    delete iChangeFinder;

    delete iConverter;

    if ( iDataBaseOpened )

        {

        iDb.Close();

        iRootFolder.Close();

        iFeedsServer.Close();

        }

    iSession.Close();

    iRfs.Close();

    LOGGER_LEAVEFN( "~CBookmarkDataStore" );

    }

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

// CBookmarkDataStore::NewL

// Two-phased constructor.

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

CBookmarkDataStore* CBookmarkDataStore::NewL()

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::NewL" );

    CBookmarkDataStore* self = CBookmarkDataStore::NewLC();

    CleanupStack::Pop( self );

    LOGGER_LEAVEFN( "CBookmarkDataStore::NewL" );

    return self;

    }

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

// CBookmarkDataStore::NewLC

// Two-phased constructor.

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

CBookmarkDataStore* CBookmarkDataStore::NewLC()

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::NewLC" );

    CBookmarkDataStore* self = new ( ELeave ) CBookmarkDataStore();

    CleanupStack::PushL( self );

    self->ConstructL();

    LOGGER_LEAVEFN( "CBookmarkDataStore::NewLC" );

    return self;

    }

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

// CBookmarkDataStore::DoOpenL

// Opens database.

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

void CBookmarkDataStore::DoOpenL( const TDesC& /*aStoreName*/,

    MSmlSyncRelationship& aContext, TRequestStatus& aStatus )

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::DoOpenL" );

    iCallerStatus = &aStatus;           

    *iCallerStatus = KRequestPending;

    if ( iDataBaseOpened )

        {

        User::RequestComplete( iCallerStatus, KErrInUse );

        LOGGER_WRITE( "CBookmarkDataStore::DoOpenL failed with KErrInUse." );

        return;

        }

    // Create ChangeFinder

    if ( iChangeFinder )

        {

        delete iChangeFinder;

        iChangeFinder = NULL;

        }

    iChangeFinder = CChangeFinder::NewL( aContext, iKey, iHasHistory );

    // Create converter object

    if ( iConverter )

        {

        delete iConverter;

        iConverter = NULL;

        }

    iConverter = CBookmarkConversionUtil::NewL();

    TInt err( KErrNone );       

    err = iDb.Open( iSession, KBrowserBookmarks );

    if ( err )

        {

        LOGGER_WRITE_1( "CBookmarkDataStore::DoOpenL iDb.Open err: %d.", err );

        User::RequestComplete( iCallerStatus, err );

        return;

        }

    err = iFeedsServer.Connect();

    if ( err )

        {

        LOGGER_WRITE_1( "CBookmarkDataStore::DoOpenL iFeedsServer.Connect err: %d.", err );

        User::RequestComplete( iCallerStatus, err );

        return;

        }

    err = iRootFolder.Open( iFeedsServer );

    if ( err )

        {

        LOGGER_WRITE_1( "CBookmarkDataStore::DoOpenL iRootFolder.Open err: %d.", err );

        User::RequestComplete( iCallerStatus, err );

        return;

        }

    iRootFolder.FetchRootFolderItemL(); // calls FolderItemRequestCompleted when completed

    LOGGER_LEAVEFN( "CBookmarkDataStore::DoOpenL" );

    }

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

// CBookmarkDataStore::FolderItemRequestCompleted

// RSS item database request is completed

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

void CBookmarkDataStore::FolderItemRequestCompleted( TInt aStatus,

    CRequestHandler::TRequestHandlerType )

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::FolderItemRequestCompleted" );

    TRAPD( err, DoFolderItemRequestCompletedL( aStatus ) );

    if ( err != KErrNone )

        {

        LOGGER_WRITE_1( "DoFolderItemRequestCompletedL leaved with err: %d", err );

        User::RequestComplete( iCallerStatus, err );

        }

    LOGGER_LEAVEFN( "CBookmarkDataStore::FolderItemRequestCompleted" );

    }

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

// CBookmarkDataStore::DoFolderItemRequestCompletedL

// RSS item database request is completed

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

void CBookmarkDataStore::DoFolderItemRequestCompletedL( TInt aStatus )

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::DoFolderItemRequestCompletedL" );

    switch ( iCurrentState )

        {

        case EClosed : 

            {

            LOGGER_WRITE("Database ready");

            iDataBaseOpened = ETrue;

            iCurrentState = EOpenAndWaiting;

            RegisterSnapshotL();

            break;

            }

        // bookmark is added (Add command)

        case EBookmarkCreating :

           	{

           	// RSS Item has been created.

           	LOGGER_WRITE_1("RSS item created, err %d", aStatus);

           	// Restore state

           	iCurrentState = EOpenAndWaiting;

            if ( aStatus == KErrNone )

                {

                RssItemCreatedL();

                }

            break;

            }

        // bookmark is updated (Replace command)

        case EBookmarkUpdating :

            {

            LOGGER_WRITE("RSS item replaced");

            if ( aStatus == KErrNone )

                {

                TBool moveNeeded(EFalse);

                RssItemReplacedL( moveNeeded );

                if ( moveNeeded )

                    {

                    // Moving is still ongoing, don't complete request yet.

                    return;

                    }

                LOGGER_WRITE_1("Item ID: %d", *iCurrentItem);

                LOGGER_WRITE_1("Parent ID: %d", iParentFolder);

                }

            // Restore state

            iCurrentState = EOpenAndWaiting;

            break;

            }

        // bookmark is updated and moved (Replace command, 2nd phase)

        case EBookmarkUpdatedAndMoving:

            {

            LOGGER_WRITE_1( "RSS item moved (replaced), err: %d", aStatus );

            if ( aStatus == KErrNone )

                {

                // Inform ChangeFinder of updated item

                iChangeFinder->ItemUpdatedL( *iMovedItem ); // ownership transferred

                iMovedItem = NULL;

                LOGGER_WRITE( "ItemReplacedL" );

                }

            else

                {

                delete iMovedItem;

                iMovedItem = NULL;

                }

            // Restore state

            iCurrentState = EOpenAndWaiting;

            break;

            }

        // bookmark is moved (Move command)

        case EBookmarkMoving:

            {

            LOGGER_WRITE_1( "RSS item moved, err: %d", aStatus );

            if ( aStatus == KErrNone )

                {

                iChangeFinder->ItemMovedL( *iMovedItem ); // ownership transferred

                iMovedItem = NULL;

                }

            else

                {

                delete iMovedItem;

                iMovedItem = NULL;

                }

            // Restore state

            iCurrentState = EOpenAndWaiting;

            break;

            }

        case EBookmarkDeleting:

            {

            LOGGER_WRITE_1( "RSS item removed, err: %d", aStatus );

            if ( aStatus == KErrNone )

                {

                // Inform ChangeFinder of the removed item

                TSnapshotItem item( iReplaceItem );     

                iChangeFinder->ItemDeletedL( item );

                }

            // Restore state

            iCurrentState = EOpenAndWaiting;

            break;

            }

        case EBookmarkDeletingAll:

            {

            LOGGER_WRITE_1( "all RSS items removed, err: %d", aStatus );

            break;

            }

        default :

            LOGGER_WRITE_1( "Invalid state: %d", iCurrentState );

            return;

        }

    User::RequestComplete( iCallerStatus, aStatus );

    LOGGER_LEAVEFN( "CBookmarkDataStore::DoFolderItemRequestCompletedL" ); 

    }

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

// CBookmarkDataStore::RssItemCreatedL

// Rss item has been created, add item to changefinder

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

void CBookmarkDataStore::RssItemCreatedL()

    {

    TRACE_FUNC_ENTRY;

    if ( !iRootFolder.HasRootFolderItem() )

        {

        LOGGER_WRITE( "rss root folder not found" );

        User::Leave( KErrNotFound );

        }

    const CFolderItem& rootFolder = iRootFolder.RootFolderItem();

    const CFolderItem* parent = rootFolder.Search( iParentFolder - KRssFeedsOffset );

    if ( !parent )

        {

        LOGGER_WRITE( "parent folder not found" );

        User::Leave( KErrNotFound );

        }

    LOGGER_WRITE_1("parent->Id(): %d", parent->Id());

    LOGGER_WRITE_1( "Name: %S", &iNewItemName );

    const CFolderItem* addedItem = parent->Search( iNewItemName );

    iNewItemName.Zero();

    if ( addedItem )

        {

        LOGGER_WRITE_1("addedItem found, id: %d", addedItem->Id());

        // Output the uid value of new item

        *iCurrentItem = addedItem->Id() + KRssFeedsOffset;

        // Inform ChangeFinder of the added item

        TSnapshotItem snapshotItem( *iCurrentItem );

        snapshotItem.SetParentId( iParentFolder );

        snapshotItem.CreateHashL( addedItem->Name(), addedItem->SourceUrl() );

        iChangeFinder->ItemAddedL( snapshotItem );

        LOGGER_WRITE( "ItemAddedL" );

        }

    else

        {

        LOGGER_WRITE( "Added item not found" );

        User::Leave( KErrNotFound );

        }

    LOGGER_WRITE_1("Item ID: %d", *iCurrentItem);

    LOGGER_WRITE_1("Parent ID: %d", iParentFolder);

    TRACE_FUNC_EXIT;

    }

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

// CBookmarkDataStore::RssItemReplacedL

// Rss item has been replaced, update changefinder

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

void CBookmarkDataStore::RssItemReplacedL( TBool& aMoveNeeded )

    {

    TRACE_FUNC_ENTRY;

    aMoveNeeded = EFalse;

    if ( !iRootFolder.HasRootFolderItem() )

        {

        LOGGER_WRITE( "rss root folder not found" );

        User::Leave( KErrNotFound );

        }

    const CFolderItem& rootFolder = iRootFolder.RootFolderItem();

    LOGGER_WRITE_1( "rootFolder.Search %d", iReplaceItem - KRssFeedsOffset );

    const CFolderItem* modItem = rootFolder.Search( iReplaceItem - KRssFeedsOffset );

    if ( modItem )

        {

        LOGGER_WRITE_1("Item found, id: %d", modItem->Id());

        const CFolderItem* parent = modItem->Parent();

        if ( parent )

            {

            TInt currentParent = parent->Id() + KRssFeedsOffset;

            if ( iParentFolder != parent->Id() + KRssFeedsOffset )

                {

                // move to another folder

                const CFolderItem* newParent = rootFolder.Search(

                    iParentFolder - KRssFeedsOffset );

                if ( !newParent )

                    {

                    // new parent not found

                    LOGGER_WRITE( "new parent not found" );

                    User::Leave( KErrPathNotFound );

                    }

                else if ( !newParent->IsFolder() )

                    {

                    // not a folder

                    LOGGER_WRITE( "parent is not a folder" );

                    User::Leave( KErrPathNotFound );

                    }

                else

                    {

                    // Output the uid value of new item

                    *iCurrentItem = modItem->Id() + KRssFeedsOffset;

                    iCurrentState = EBookmarkUpdatedAndMoving;

                    RPointerArray<const CFolderItem> movedItems;

                    CleanupClosePushL( movedItems );

                    // FolderItemRequestCompleted is called when ready

                    iRootFolder.MoveFolderItemsToL( movedItems, *newParent);

                    CleanupStack::PopAndDestroy( &movedItems );

                    aMoveNeeded = ETrue;

                    delete iMovedItem;

                    iMovedItem = NULL;

                    iMovedItem = new (ELeave) TSnapshotItem( *iCurrentItem ,

                        iParentFolder );

                    iMovedItem->CreateHashL( modItem->Name(), modItem->SourceUrl() );

                    LOGGER_WRITE( "ItemReplacedL,waiting to move item.." );

                    return;

                    }

                }

            }

        else

            {

            //parent not found

            LOGGER_WRITE( "rss parent not defined" );

            }

        // Output the uid value of new item

        *iCurrentItem = modItem->Id() + KRssFeedsOffset;

        // Inform ChangeFinder of updated item

        TSnapshotItem snapshotItem( *iCurrentItem, iParentFolder );

        snapshotItem.CreateHashL( modItem->Name(), modItem->SourceUrl() );

        iChangeFinder->ItemUpdatedL( snapshotItem );

        LOGGER_WRITE( "ItemReplacedL" );

        }

    else

        {

        LOGGER_WRITE_1( "Replaced item %d not found",iReplaceItem - KRssFeedsOffset );

        User::Leave( KErrNotFound );

        }

    TRACE_FUNC_EXIT;

    }

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

// CBookmarkDataStore::DoCancelRequest

// Not supported, does nothing.

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

void CBookmarkDataStore::DoCancelRequest()

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::DoCancelRequest" );

    LOGGER_LEAVEFN( "CBookmarkDataStore::DoCancelRequest" );    

    }

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

// CBookmarkDataStore::DoStoreName

// Returns the name of the DataStore

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

const TDesC& CBookmarkDataStore::DoStoreName() const

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::DoStoreName" );

    LOGGER_LEAVEFN( "CBookmarkDataStore::DoStoreName" );

    if ( iDataBaseOpened )

        {

        return KBrowserBookmarks;

        }

    else

        {

        return KNullDesC;

        }

    }

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

// CBookmarkDataStore::DoBeginTransactionL

// Transactions are not supported.

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

void CBookmarkDataStore::DoBeginTransactionL()

    {

    LOGGER_ENTERFN( "CBookmarkDataStore::DoBeginTransactionL" );

    LOGGER_WRITE( "CBookmarkDataStore::DoBeginTransactionL leaved with KErrNotSupported." )

    User::Leave( KErrNotSupported );

    }

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

// CBookmarkDataStore::DoCommitTransactionL