/*

* 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 <e32base.h>

#include <msvstd.h>

#include <msvapi.h>

#include <msvids.h>

#include <mtclreg.h>

#include <centralrepository.h>

// This is used, when databuffer is not initialized

const TInt KDataBufferNotReady = -1;

// Size for internal CBufFlat, used to buffer SMS messages

const TInt KDataBufferSize = 1024;

_LIT8(KSmsMimeType, "text/x-vMessage");

_LIT8(KSmsMimeVersion, "1.2");

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

_LIT8(KFolderMimeVersion, "1.2");

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

// CSmsDataStore::CSmsDataStore

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

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

CSmsDataStore::CSmsDataStore():

    iHasHistory(EFalse),

    iDataBaseOpened(EFalse),

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

    { 

    }

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

// CSmsDataStore::ConstructL

// Symbian 2nd phase constructor, can leave.

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

void CSmsDataStore::ConstructL()

    {

	LOGGER_ENTERFN("CSmsDataStore::ConstructL");

    iMsvApi = CSmsAdapterMsvApi::NewL();

	// Item UID sets, used to transfer change info

    iNewItems = new (ELeave) CNSmlDataItemUidSet;

    iDeletedItems = new (ELeave) CNSmlDataItemUidSet;

    iUpdatedItems = new (ELeave) CNSmlDataItemUidSet;

    iMovedItems = new (ELeave) CNSmlDataItemUidSet;

    iSoftDeletedItems = new (ELeave) CNSmlDataItemUidSet;

	iMessageParser = CVMessageParser::NewL();

	iFolderObjectParser = COMADSFolderObject::NewL();

	LOGGER_LEAVEFN("CSmsDataStore::ConstructL");

    }

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

// CSmsDataStore::NewLC

// Two-phased constructor.

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

CSmsDataStore* CSmsDataStore::NewLC()

    {

    CSmsDataStore* self = new (ELeave) CSmsDataStore;

	CleanupStack::PushL(self);

  	self->ConstructL();

    return self;    

    }

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

// CSmsDataStore::~CSmsDataStore

// Destructor

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

CSmsDataStore::~CSmsDataStore()

    {

    LOGGER_ENTERFN("CSmsDataStore::~CSmsDataStore()");

    SAFEDELETE(iFolderObjectParser);

    SAFEDELETE(iMessageParser);

    SAFEDELETE(iMsvApi);

	SAFEDELETE(iChangeFinder); 	

	// UID sets

	SAFEDELETE(iNewItems);

	SAFEDELETE(iDeletedItems);

	SAFEDELETE(iSoftDeletedItems);

	SAFEDELETE(iUpdatedItems);

	SAFEDELETE(iMovedItems);

	SAFEDELETE(iDataBuffer);

	LOGGER_LEAVEFN("CSmsDataStore::~CSmsDataStore()");

    }

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

// CSmsDataStore::DoOpenL

// Opens database. This operation is performed SYNCHRONOUSLY

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

void CSmsDataStore::DoOpenL(const TDesC& /*aStoreName*/, MSmlSyncRelationship& aContext, 

    TRequestStatus& aStatus)

    {

	LOGGER_ENTERFN("CSmsDataStore::DoOpenL");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	if (iDataBaseOpened)

		{

		User::RequestComplete(iCallerStatus, KErrInUse);

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

		return;

		}

    *iContext = aContext;

	// Create ChangeFinder object

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

    RegisterSnapshotL();

    iDataBaseOpened = ETrue;

    iCurrentState = ESmsOpenAndWaiting;

	User::RequestComplete(iCallerStatus, KErrNone);	

	LOGGER_LEAVEFN("CSmsDataStore::DoOpenL");

	}

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

// CSmsDataStore::DoCancelRequest

// Not supported, does nothing.

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

void CSmsDataStore::DoCancelRequest()

	{

	LOGGER_ENTERFN("CSmsDataStore::DoCancelRequestL");

	LOGGER_LEAVEFN("CSmsDataStore::DoCancelRequestL");

	}

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

// CSmsDataStore::DoStoreName

// Returns the name of the DataStore

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

const TDesC& CSmsDataStore::DoStoreName() const

	{

	LOGGER_ENTERFN("CSmsDataStore::DoStoreName");

	if (iDataBaseOpened)

		{

		LOGGER_LEAVEFN("CSmsDataStore::DoStoreName");

	    return KNSmlDefaultLocalDbName;

	    }

	LOGGER_LEAVEFN("CSmsDataStore::DoStoreName");

    return KNullDesC;

	}

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

// CSmsDataStore::DoBeginTransactionL

// Transactions are not supported.

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

void CSmsDataStore::DoBeginTransactionL()

 	{

 	LOGGER_ENTERFN("CSmsDataStore::DoBeginTransactionL");

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

 	User::Leave(KErrNotSupported);

	}

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

// CSmsDataStore::DoCommitTransactionL

// Transactions are not supported.

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

void CSmsDataStore::DoCommitTransactionL(TRequestStatus& aStatus)

    {

	LOGGER_ENTERFN("CSmsDataStore::DoCommitTransactionL"); 

	LOGGER_WRITE("CSmsDataStore::DoCommitTransactionL failed with KErrNotSupported.");

	iCallerStatus = &aStatus;

	User::RequestComplete(iCallerStatus, KErrNotSupported);

	LOGGER_LEAVEFN("CSmsDataStore::DoCommitTransactionL");

	}

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

// CSmsDataStore::DoRevertTransaction

// Transactions are not supported.

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

void CSmsDataStore::DoRevertTransaction(TRequestStatus& aStatus)

    {

	LOGGER_ENTERFN("CSmsDataStore::DoRevertTransaction"); 

	iCallerStatus = &aStatus;

	User::RequestComplete(iCallerStatus, KErrNone);	

	LOGGER_LEAVEFN("CSmsDataStore::DoRevertTransaction");

	}

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

// CSmsDataStore::DoBeginBatchL

// Batching is not supported.

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

void CSmsDataStore::DoBeginBatchL()

	{

	LOGGER_ENTERFN("CSmsDataStore::DoBeginBatchL");

	LOGGER_WRITE("CSmsDataStore::DoBeginBatchL leaved with KErrNotSupported.");

	User::Leave(KErrNotSupported);	

	}

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

// CSmsDataStore::DoCommitBatchL

// Batching is not supported

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

//

void CSmsDataStore::DoCommitBatchL(RArray<TInt>& /*aResultArray*/, TRequestStatus& aStatus)

	{

	LOGGER_ENTERFN("CSmsDataStore::DoCommitBatchL");	

	LOGGER_WRITE("CSmsDataStore::DoCommitBatchL failed with KErrNotSupported");

	iCallerStatus = &aStatus;

	User::RequestComplete(iCallerStatus, KErrNotSupported);

	LOGGER_LEAVEFN("CSmsDataStore::DoCommitBatchL");

	}

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

// CSmsDataStore::DoCancelBatch

// Batching is not supported

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

void CSmsDataStore::DoCancelBatch()

	{

	LOGGER_ENTERFN("CSmsDataStore::DoCancelBatch");

	LOGGER_LEAVEFN("CSmsDataStore::DoCancelBatch");

	}

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

// CSmsDataStore::DoSetRemoteStoreFormatL

// Not supported

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

//

void CSmsDataStore::DoSetRemoteStoreFormatL(const CSmlDataStoreFormat& /*aServerDataStoreFormat*/)

	{

	LOGGER_ENTERFN("CSmsDataStore::DoSetRemoteStoreFormatL");

	LOGGER_LEAVEFN("CSmsDataStore::DoSetRemoteStoreFormatL");

	}

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

// CSmsDataStore::DoSetRemoteMaxObjectSize

// Not supported

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

void CSmsDataStore::DoSetRemoteMaxObjectSize(TInt /*aServerMaxObjectSize*/)

 	{

	LOGGER_ENTERFN("CSmsDataStore::DoSetRemoteMaxObjectSize");

	LOGGER_LEAVEFN("CSmsDataStore::DoSetRemoteMaxObjectSize");

	}

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

// CSmsDataStore::DoMaxObjectSize

// 

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

TInt CSmsDataStore::DoMaxObjectSize() const

	{

	LOGGER_ENTERFN("CSmsDataStore::DoMaxObjectSize");

    LOGGER_LEAVEFN("CSmsDataStore::DoMaxObjectSize");

    return 0;

	}

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

// CSmsDataStore::DoOpenItemL

// Opens item in the DataStore, reads it (either completely or partially) 

// to the temporary buffer where it can be later read to the remote database.

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

void CSmsDataStore::DoOpenItemL(TSmlDbItemUid aUid, TBool& aFieldChange, 

	TInt& aSize, TSmlDbItemUid& aParent, TDes8& aMimeType, 

	TDes8& aMimeVer, TRequestStatus& aStatus)

	{

	LOGGER_ENTERFN("CSmsDataStore::DoOpenItemL");

    LOGGER_WRITE_1("Opening item %d.", aUid);

	// Store these for later use

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	// Check that we're in a proper state

	if (iCurrentState != ESmsOpenAndWaiting)

		{

		LOGGER_WRITE_1("CSmsDataStore::DoOpenItemL, Incorrect state: %d", iCurrentState);

		}

    // Allocate new buffer

    SAFEDELETE(iDataBuffer);

    iDataBuffer = CBufFlat::NewL(KDataBufferSize);

    TBool userFolderFound(EFalse);

    TTime timeStamp;

    TPtrC folderName;

    userFolderFound = iMsvApi->FindUserFolderL(aUid, folderName, timeStamp);

    if (userFolderFound)

        {

        iMimeType = EMessageFolder;

        iParentId = KMsvMyFoldersEntryIdValue;

        iFolderObjectParser->SetName(folderName);

        iFolderObjectParser->SetCreatedDate(timeStamp.DateTime());

        iFolderObjectParser->SetModifiedDate(timeStamp.DateTime());

        iFolderObjectParser->ExportFolderXmlL(*iDataBuffer); 

        }

    else

        {

        iMimeType = ESmsMessage;        

        iMessageParser->ResetAll();

        TBool unread;

        TMsvId parent;

        TRAPD(error, iMsvApi->RetrieveSML(aUid, parent, *iMessageParser, unread));

        if(error != KErrNone)

		    {

		    User::RequestComplete(iCallerStatus, KErrNotFound); 

		    LOGGER_WRITE_1("RetrieveSML(aUid, &parser, flags) leaved with %d.", error);

		    return;

		    }

        iParentId = parent;

        iMessageParser->ConstructMessageL(*iDataBuffer);

        }

    // Adjust buffer

    iDataBuffer->Compress();

    iReaderPosition = 0;

    iCurrentState = ESmsItemOpen;		

	// Return these

	aFieldChange = EFalse;

	aParent = iParentId;

    aSize = iDataBuffer->Size();

    if (iMimeType == EMessageFolder)

        {

        TInt targetLength = KFolderMimeType().Length();

    	if (aMimeType.MaxLength() < targetLength)

    	    targetLength = aMimeType.MaxLength();

    	aMimeType.Copy(KFolderMimeType().Ptr(), targetLength);

        // Set mime version (do not exceed the allocated buffer)

    	targetLength = KFolderMimeVersion().Length();

    	if (aMimeVer.MaxLength() < targetLength)

    	    targetLength = aMimeVer.MaxLength();

    	aMimeVer.Copy(KFolderMimeVersion().Ptr(), targetLength);

        }

    else // ESmsMessage

        {   

    	TInt targetLength = KSmsMimeType().Length();

    	if (aMimeType.MaxLength() < targetLength)

    	    targetLength = aMimeType.MaxLength();

    	aMimeType.Copy(KSmsMimeType().Ptr(), targetLength);

        // Set mime version (do not exceed the allocated buffer)

    	targetLength = KSmsMimeVersion().Length();

    	if (aMimeVer.MaxLength() < targetLength)

    	    targetLength = aMimeVer.MaxLength();

    	aMimeVer.Copy(KSmsMimeVersion().Ptr(), targetLength);

        }

   	// Signal we're complete

	User::RequestComplete(iCallerStatus, KErrNone); 

	LOGGER_LEAVEFN("CSmsDataStore::DoOpenItemL");

	}

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

// CSmsDataStore::DoCreateItemL

// Create new item to the message store.

// Return the id number of the newly created item

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

void CSmsDataStore::DoCreateItemL(TSmlDbItemUid& aUid, TInt aSize, 

    TSmlDbItemUid aParent, const TDesC8& aMimeType, const TDesC8& /*aMimeVer*/, 

    TRequestStatus& aStatus)

	{

	LOGGER_ENTERFN("CSmsDataStore::DoCreateItemL");

	// Store some variables for further use

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	// Ensure that we're in proper state

	if (iCurrentState != ESmsOpenAndWaiting)

		{

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

		}	

	// Check MIME type

	LOG(aMimeType);

	if (aMimeType.Compare( KFolderMimeType() ) == 0)	

		{

		iMimeType = EMessageFolder;

		}

	else if (aMimeType.Compare( KSmsMimeType() ) == 0)

		{

		iMimeType = ESmsMessage;

		}

	else

		{

		User::RequestComplete( iCallerStatus, KErrNotSupported );

		LOGGER_WRITE("Bad MIME type");

		return;

		}

	LOGGER_WRITE_1( "Parent folder: %d", aParent);

	if ((iMimeType == EMessageFolder && aParent != KMsvMyFoldersEntryIdValue) ||

	    (iMimeType == ESmsMessage && !iMsvApi->ValidFolderL(aParent)))

	    {

		User::RequestComplete( iCallerStatus, KErrNotSupported );

		LOGGER_WRITE( "Bad parent folder");

		return;	    

	    }

	// Ensure that we've got enough disk space for the item

	if(iMsvApi->DiskSpaceBelowCriticalLevelL(aSize))

		{

		User::RequestComplete(iCallerStatus, KErrDiskFull);

		LOGGER_WRITE("Disk full");

		return;

		}	

    // Store uid values

    iCreatedUid = &aUid;

	iParentId = aParent; 

    // Create message buffer, item will be written into this buffer

	SAFEDELETE(iDataBuffer);

	iDataBuffer = CBufFlat::NewL(KDataBufferSize);

	iWriterPosition = 0;

	iCurrentState = ESmsItemCreating;

	// Signal we're complete

	User::RequestComplete( iCallerStatus, KErrNone );

    LOGGER_LEAVEFN("CSmsDataStore::DoCreateItemL");

	}

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

// CSmsDataStore::DoReplaceItemL

// Begin the replace operation, ensure that the item really exists

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

void CSmsDataStore::DoReplaceItemL(TSmlDbItemUid aUid, TInt aSize, TSmlDbItemUid aParent, 

    TBool /*aFieldChange*/, TRequestStatus& aStatus)

	{

	LOGGER_ENTERFN("CSmsDataStore::DoReplaceItemL");

	LOGGER_WRITE_1("Replacing item %d.", aUid);

	LOGGER_WRITE_1("Parent folder: %d.", aParent);

	// Store some variables for further use

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	// Ensure proper state

	if (iCurrentState != ESmsOpenAndWaiting)

		{

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

		}

	// Ensure that we've got enough disk space for the item

	if (iMsvApi->DiskSpaceBelowCriticalLevelL(aSize))

		{

		User::RequestComplete(iCallerStatus, KErrDiskFull);

		LOGGER_WRITE("Disk full");

		return;

		}

	// Find entry

	CMsvEntry* entry(NULL);

	TRAPD(error, entry = iMsvApi->MsvSessionL()->GetEntryL(aUid));

	if (error != KErrNone)

		{

		User::RequestComplete(iCallerStatus, KErrNotFound);

		LOGGER_WRITE("Item not found");

		return;

		}

	// This is the representation of the actual message

	TMsvEntry tEntry = entry->Entry();

	// Not needed anymore

	SAFEDELETE(entry);	

	// Check entry type

	if (tEntry.iType == KUidMsvFolderEntry)

	    {

	    iMimeType = EMessageFolder;

	    LOGGER_WRITE("Type: folder");

	    }

	else

	    {

	    iMimeType = ESmsMessage;

	    LOGGER_WRITE("Type: SMS message");

	    }   

    if ((iMimeType == EMessageFolder && aParent != KMsvMyFoldersEntryIdValue) ||

        (iMimeType == ESmsMessage && !iMsvApi->ValidFolderL(aParent) ||

        (aParent != tEntry.Parent())))

        {

        User::RequestComplete(iCallerStatus, KErrNotSupported);

        LOGGER_WRITE_1("Bad parent folder, message entry parent is %d", tEntry.Parent());

        return;    

        }    

	// Store these for further use

	iParentId = aParent;