/*

* Copyright (c) 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:  CSconSyncHandler implementation

*

*/

#include "sconsynchandler.h"

#include <f32file.h>

#include <S32MEM.H>

#include <UTF.H>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <bautils.h>

#include <nsmlconstants.h>

#include <centralrepository.h>

#include "debug.h"

// versions up to 5 must be backward compatible

const TUint16 KFormatVersionNumber ( 1 );

_LIT8(KCommandListStores, "SYNC: ListStores");

_LIT8(KCommandOpenStore, "SYNC: OpenStore: ");

_LIT8(KCommandCloseStore, "SYNC: CloseStore");

_LIT8(KCommandListChanges, "SYNC: ListChanges");

_LIT8(KCommandResetChangeInfo, "SYNC: ResetChangeInfo");

_LIT8(KCommandCommitChanges, "SYNC: CommitChanges: ");

_LIT8(KCommandReadItems, "SYNC: ReadItems: ");

_LIT8(KCommandGetParents, "SYNC: GetParents: ");

_LIT8(KCommandCreateItems, "SYNC: CreateItems");

_LIT8(KCommandGetCreateItemsResponse, "SYNC: GetCreateItemsResponse");

_LIT8(KCommandGetCreateItems, "SYNC: GetCreateItems: ");

_LIT8(KCommandReplaceItems, "SYNC: ReplaceItems");

_LIT8(KCommandGetReplaceItemsResponse, "SYNC: GetReplaceItemsResponse");

_LIT8(KCommandGetReplaceItems, "SYNC: GetReplaceItems: ");

_LIT8(KCommandMoveItems, "SYNC: MoveItems");

_LIT8(KCommandDeleteItems, "SYNC: DeleteItems: ");

_LIT8(KCommandSoftDeleteItems, "SYNC: SoftDeleteItems: ");

_LIT8(KCommandDeleteAllItems, "SYNC: DeleteAllItems");

_LIT8(KCommandDeleteAllItemsStatus, "SYNC: GetDeleteAllItemsStatus");

_LIT8(KCommandGetStoreFormat, "SYNC: GetStoreFormat");

_LIT8(KCommandSetRemoteStoreFormat, "SYNC: SetRemoteStoreFormat");

_LIT8(KCommandGetRestOfData, "SYNC: GetRestOfData");

_LIT8(KCommandCancel, "SYNC: Cancel");

_LIT(KRemoteFormatStore, "remoteformatstore_0x%08x.dat");

_LIT(KDataFileExtension, ".tmp");

const TInt KTimeStampLength = 16;

_LIT8(KTimeStampFormat, "%02d%02d%04dT%02d%02d%02dZ");

const TInt KDefaultExpandSize = 1024;

// Calendar sync specific constants

const TInt KCalendarDsUid = 0x101F6DDE;

CSconSyncHandler::~CSconSyncHandler()

    {

    TRACE_FUNC_ENTRY;

    Cancel();

    iSyncSession.Close();

    delete iResponseData;

    iFileStream.Close();

    iCreatedItems.Close();

    iReplacedItems.Close();

    iItemsToRead.Close();

    iFs.Delete( iFileInProgress );

    ClearCalendarCenrepL();

    TRACE_FUNC_EXIT;

    }

CSconSyncHandler::CSconSyncHandler( RFs& aFs ) 

    : CActive( EPriorityStandard ), iFs(aFs), iCreatedItemUidPckg(iCreatedItemUid)

    {

    CActiveScheduler::Add( this );

    }

CSconSyncHandler* CSconSyncHandler::NewL( RFs& aFs)

    {

    TRACE_FUNC_ENTRY;

    CSconSyncHandler* self = new (ELeave) CSconSyncHandler(aFs);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_FUNC_EXIT;

    return self;

    }

void CSconSyncHandler::ConstructL()

    {

    TInt err = iFs.CreatePrivatePath( EDriveC );

    LOGGER_WRITE_1("CreatePrivatePath err: %d", err);

    iFs.SetSessionToPrivate( EDriveC );

    }

void CSconSyncHandler::HandleGetSyncRequestL( const TDesC8& aRequest, RWriteStream& aResult, TInt aMaxObjectSize )

    {

    TRACE_FUNC_ENTRY;

    iMaxObjectSize = aMaxObjectSize;

    iBytesWrited = 0;

    LOGGER_WRITE_1("iMaxObjectSize: %d", iMaxObjectSize);

    if ( !iConnected )

        {

        LOGGER_WRITE("Try to connect")

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

        iConnected = ETrue;

        }

    if ( aRequest.Compare( KCommandListStores ) == KErrNone )

        {

        ListStoresL( aResult );

        }

    else if ( aRequest.Find( KCommandOpenStore ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandOpenStore().Length() );

        OpenStoreL( params, aResult );

        }

    else if ( aRequest.Find( KCommandCloseStore ) == 0 )

        {

        CloseStoreL( aResult );

        }

    else if ( aRequest.Find( KCommandListChanges ) == 0 )

        {

        ListChangesL( aResult );

        }

    else if ( aRequest.Find( KCommandResetChangeInfo ) == 0 )

        {

        ResetChangeInfoL( aResult );

        }

    else if ( aRequest.Find( KCommandCommitChanges ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandCommitChanges().Length() );

        CommitChangesL( params, aResult );

        }

    else if ( aRequest.Find( KCommandReadItems ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandReadItems().Length() );

        ReadItemsL( params, aResult );

        }

    else if ( aRequest.Find( KCommandGetParents ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandGetParents().Length() );

        GetParentsL( params, aResult );

        }

    else if ( aRequest.Find( KCommandGetRestOfData ) == 0 )

        {

        // Get rest of data

        ReadNextDataBlockL( aResult );

        }

    else if ( aRequest.Find( KCommandGetCreateItemsResponse ) == 0 )

        {

        GetCreateItemsResponseL( KNullDesC8(), aResult );

        }

    else if ( aRequest.Find( KCommandGetCreateItems ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandGetCreateItems().Length() );

        GetCreateItemsResponseL( params, aResult );

        }

    else if ( aRequest.Find( KCommandGetReplaceItemsResponse ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandGetReplaceItemsResponse().Length() );

        GetReplaceItemsResponseL( KNullDesC8(), aResult );

        }

    else if ( aRequest.Find( KCommandGetReplaceItems ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandGetReplaceItems().Length() );

        GetReplaceItemsResponseL( params, aResult );

        }

    else if ( aRequest.Find( KCommandMoveItems ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandMoveItems().Length() );

        MoveItemsL( params, aResult );

        }

    else if ( aRequest.Find( KCommandDeleteItems ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandDeleteItems().Length() );

        DeleteItemsL( params, aResult );

        }

    else if ( aRequest.Find( KCommandSoftDeleteItems ) == 0 )

        {

        TPtrC8 params = aRequest.Mid( KCommandSoftDeleteItems().Length() );

        SoftDeleteItemsL( params, aResult );

        }

    else if ( aRequest.Find( KCommandDeleteAllItems ) == 0 )

        {

        DeleteAllItemsL( aResult );

        }

    else if ( aRequest.Find( KCommandDeleteAllItemsStatus ) == 0 )

        {

        GetDeleteAllItemsStatusL( aResult );

        }

    else if ( aRequest.Find( KCommandGetStoreFormat ) == 0 )

        {

        GetStoreFormatL( aResult );

        }

    else if ( aRequest.Find( KCommandCancel ) == 0 )

        {

        CancelOperationsL( aResult );

        }

    else    

        {

        LOGGER_WRITE("Unknown command");

        User::Leave( KErrNotSupported );

        }

    TRACE_FUNC_EXIT;

    }

void CSconSyncHandler::HandlePutSyncRequestL( const TDesC8& aRequest, RReadStream& aData )

    {

    TRACE_FUNC_ENTRY;

    if ( !iConnected )

        {

        LOGGER_WRITE("Try to connect")

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

        iConnected = ETrue;

        }

    if ( aRequest.Find( KCommandCreateItems ) == KErrNone )

        {

        CreateItemsL( aData );

        }

    else if ( aRequest.Find( KCommandReplaceItems ) == 0 )

        {

        ReplaceItemsL( aData );

        }

    else if ( aRequest.Find( KCommandSetRemoteStoreFormat ) == 0 )

        {

        SetRemoteStoreFormatL( aData );

        }

    else

        {

        LOGGER_WRITE("Unknown command");

        User::Leave( KErrNotSupported );

        }

    TRACE_FUNC_EXIT;

    }

void CSconSyncHandler::ListStoresL( RWriteStream& aResult )

    {

    TRACE_FUNC_ENTRY;

    RSconDataProviderInfoArray infoArray(5);

    CleanupResetAndDestroyPushL( infoArray );

    iSyncSession.ListAllImplementationsL( infoArray );

    LOGGER_WRITE_1("infoArray.Count(): %d", infoArray.Count());

    aResult.WriteInt32L( infoArray.Count() );

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

        {

        CSconDataproviderInfo& info = (*infoArray[i]);

        info.ExternalizeL( aResult );

        }

    CleanupStack::PopAndDestroy( &infoArray );

    TRACE_FUNC_EXIT;

    }

void CSconSyncHandler::OpenStoreL( const TDesC8& aParams, RWriteStream& aResult )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE8_1("Params:'%S'", &aParams);

    const TUint8* ptr = aParams.Ptr();

    LOGGER_WRITE_1("Params size: %d", aParams.Size())

    RMemReadStream stream( ptr , aParams.Size() );

    CleanupClosePushL( stream );

    TInt providerId = stream.ReadInt32L();

    LOGGER_WRITE_1("Provider Id: 0x%08x", providerId);

    TInt contextId = stream.ReadInt32L();

    LOGGER_WRITE_1("Context Id: 0x%08x", contextId);

    // read utf8 formatted text

    TInt len = stream.ReadUint16L();

    LOGGER_WRITE_1("storeName length: %d", len);

    HBufC8* buf8 = HBufC8::NewLC( len );

    TPtr8 bufPtr8 = buf8->Des();

    stream.ReadL( bufPtr8, len );

    LOGGER_WRITE8_1("storeName8: %S", &bufPtr8);

    // and convert it to unicode

    HBufC* storeName = CnvUtfConverter::ConvertToUnicodeFromUtf8L( bufPtr8 ); 

    CleanupStack::PopAndDestroy( buf8 );

    CleanupStack::PushL( storeName );

    TPtr storeNamePtr = storeName->Des();

    LOGGER_WRITE_1("storeName: %S", &storeNamePtr);

    if ( providerId == KCalendarDsUid && aParams.Size() >

            sizeof(TInt32) // providerId

            + sizeof(TInt32) // contextId

            + sizeof(TUint16)// storeName len

            + len )          // storeName

        {

        TInt profileId = stream.ReadInt32L();

        len = stream.ReadUint16L();

        HBufC8* buffer = HBufC8::NewLC( len );

        TPtr8 bufferPtr8 = buffer->Des();

        stream.ReadL( bufferPtr8, len );

        HBufC* serverId = CnvUtfConverter::ConvertToUnicodeFromUtf8L( bufferPtr8 ); 

        CleanupStack::PopAndDestroy( buffer );

        CleanupStack::PushL( serverId );

        SetCalendarCenrepL( profileId, serverId->Des() );

        CleanupStack::PopAndDestroy(serverId);

        }

    aResult.WriteUint16L( KFormatVersionNumber );

    TRAPD( err, iSyncSession.OpenDataStoreL( providerId, storeName->Des(), contextId));

    if ( err == KErrServerTerminated )

        {

        // server terminated, try to reconnect

        iConnected = EFalse;

        LOGGER_WRITE("Try to re-connect");

        err = iSyncSession.Connect();

        LOGGER_WRITE_1("iSyncSession.Connect() err: %d", err);

        if ( !err )

            {

            iConnected = ETrue;

            TRAP( err, iSyncSession.OpenDataStoreL( providerId, storeName->Des(), contextId));

            }

        }

    CleanupStack::PopAndDestroy( storeName );

    CleanupStack::PopAndDestroy( &stream );

    aResult.WriteInt32L( err );

    if ( err )

        {

        LOGGER_WRITE_1("Error: %d", err);

        LOGGER_WRITE("iSyncSession.CloseDataStore()");

        iSyncSession.CloseDataStore();

        ClearCalendarCenrepL();

        return;

        }

    iCurrentDataProviderUid = providerId;

    iCurrentContextUid = contextId;

    // Now the store is opened

    TRAP(err, LoadRemoteStoreFormatL( contextId, providerId ));

    if ( err )

        {

        aResult.WriteUint8L( 1 ); //  Remote store format needed

        }

    else

        {

        aResult.WriteUint8L( 0 ); //  Remote store format not needed

        }

    // return last sync timestamp, if has synced before.

    TBool hasHistory = iSyncSession.HasSyncHistoryL();

    TUint8 historyFlag(0);

    if ( hasHistory )

        {

        historyFlag = 1;

        }

    aResult.WriteUint8L( historyFlag );

    if ( hasHistory )

        {

        TDateTime timeStamp;

        TInt err(KErrNone);

        TRAP(err, iSyncSession.GetSyncTimeStampL( providerId, contextId, timeStamp));

        LOGGER_WRITE_1("GetSyncTimeStampL err: %d", err);

        TBuf8<KTimeStampLength> timeStampBuf;

        timeStampBuf.Format( KTimeStampFormat, 

                timeStamp.Day()+1,timeStamp.Month()+1, timeStamp.Year(),

                timeStamp.Hour(), timeStamp.Minute(), timeStamp.Second() );

        LOGGER_WRITE8_1("timeStamp: %S", &timeStampBuf);

        aResult.WriteL( timeStampBuf );

        }

    //  for testin purposes only

    /*

    if (!remoteStoreSetted)

        {

        RStringPool pool;

        pool.OpenL();

        CleanupClosePushL( pool );

        CSmlDataStoreFormat* storeFormat(NULL);

        TRAPD( err, storeFormat = iSyncSession.StoreFormatL( pool ) );

        CleanupStack::PushL( storeFormat );

        iSyncSession.SetRemoteStoreFormatL( *storeFormat );

        SaveRemoteStoreFormatL( *storeFormat, contextId, providerId );

        CleanupStack::PopAndDestroy( storeFormat );

        CleanupStack::PopAndDestroy( &pool );

        }

    */

    TRACE_FUNC_EXIT;

    }

void CSconSyncHandler::LoadRemoteStoreFormatL( TInt aContextId, TInt aProviderId )

    {

    TRACE_FUNC_ENTRY;

    TFileName remoteFormatStore;

    iFs.SetSessionToPrivate( EDriveC );

    remoteFormatStore.Format( KRemoteFormatStore, aContextId );

    CDictionaryFileStore* dictionaryStore =

        CDictionaryFileStore::OpenLC(iFs, remoteFormatStore, TUid::Uid(0x0001));

    TBool present = dictionaryStore->IsPresentL( TUid::Uid(aProviderId) );

    if ( !present )

        {

        LOGGER_WRITE("Remote store was not saved");

        User::Leave( KErrNotFound );

        }

    else

        {

        RDictionaryReadStream stream;

        stream.OpenLC( *dictionaryStore, TUid::Uid(aProviderId) );

        RStringPool stringPool;

        stringPool.OpenL();

        CleanupClosePushL( stringPool );

        CSmlDataStoreFormat* storeFormat = CSmlDataStoreFormat::NewLC(stringPool, stream);

        iSyncSession.SetRemoteStoreFormatL( *storeFormat );

        CleanupStack::PopAndDestroy( storeFormat );

        CleanupStack::PopAndDestroy( &stringPool );

        CleanupStack::PopAndDestroy(); //OpenLC

        }

    CleanupStack::PopAndDestroy( dictionaryStore );

    TRACE_FUNC_EXIT;

    }

void CSconSyncHandler::SaveRemoteStoreFormatL( CSmlDataStoreFormat& aStoreFormat, TInt aContextId, TInt aProviderId)

    {

    TRACE_FUNC_ENTRY;

    iFs.SetSessionToPrivate( EDriveC );

    TFileName remoteFormatStore;

    remoteFormatStore.Format( KRemoteFormatStore, aContextId );

    CDictionaryFileStore* dictionaryStore =

        CDictionaryFileStore::OpenLC(iFs, remoteFormatStore, TUid::Uid(0x0001));

    RDictionaryWriteStream stream;

    stream.AssignLC( *dictionaryStore, TUid::Uid(aProviderId) );

    aStoreFormat.ExternalizeL( stream );

    stream.CommitL();

    CleanupStack::PopAndDestroy(); //AssignLC

    dictionaryStore->CommitL();

    CleanupStack::PopAndDestroy( dictionaryStore );

    TRACE_FUNC_EXIT;

    }

void CSconSyncHandler::CloseStoreL( RWriteStream& aResult )

    {

    TRACE_FUNC_ENTRY;

    iSyncSession.CloseDataStore();

    ClearCalendarCenrepL();

    // Get last used timestamp if provider was open

    if ( iCurrentDataProviderUid != 0 )

        {

        TDateTime timeStamp;

        iSyncSession.GetSyncTimeStampL(iCurrentDataProviderUid, iCurrentContextUid, timeStamp );

        iCurrentDataProviderUid = 0;

        iCurrentContextUid = 0;

        const TInt KTimeStampLength = 16;

        TBuf8<KTimeStampLength> timeStampBuf;

        timeStampBuf.Format( KTimeStampFormat, 

                timeStamp.Day()+1,timeStamp.Month()+1, timeStamp.Year(),

                timeStamp.Hour(), timeStamp.Minute(), timeStamp.Second() );

        aResult.WriteL( timeStampBuf );

        }

    TRACE_FUNC_EXIT;

    }

void CSconSyncHandler::ListChangesL( RWriteStream& aResult )

    {

    TRACE_FUNC_ENTRY;

    RArray<TSmlDbItemUid> items;

    CleanupClosePushL( items );

    iSyncSession.AddedItemsL( items );

    LOGGER_WRITE_1("Added items count: %d", items.Count());

    aResult.WriteInt32L( items.Count() );

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

        {

        aResult.WriteInt32L( items[i] );

        }

    items.Reset();

    iSyncSession.ModifiedItemsL( items );

    LOGGER_WRITE_1("Modified items count: %d", items.Count());

    aResult.WriteInt32L( items.Count() );

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

        {

        aResult.WriteInt32L( items[i] );

        }

    items.Reset();

    iSyncSession.MovedItemsL( items );

    LOGGER_WRITE_1("Moved items count: %d", items.Count());

    aResult.WriteInt32L( items.Count() );

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

        {

        aResult.WriteInt32L( items[i] );

        }

    items.Reset();

    iSyncSession.DeletedItemsL( items );

    LOGGER_WRITE_1("Deleted items count: %d", items.Count());

    aResult.WriteInt32L( items.Count() );

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

        {