/*

* Copyright (c) 2005 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:  DS notepad data store

*

*/

// INCLUDE FILES

#include <barsc.h>

#include <bautils.h>

#include <s32mem.h>

#include <sysutil.h>

#include <nsmlnotepaddatastoreformat.rsg>

#include <data_caging_path_literals.hrh>

#include <SmlDataProvider.h>

#include <txtetext.h>

#include <charconv.h>

#include <nsmlchangefinder.h>

#include "NSmlNotepadDatastore.h"

#include "nsmlnotepaddefs.h"

#include "nsmlnotepadDatabase.h"

#include "nsmlsnapshotitem.h"

#include "nsmlnotepadlogging.h"

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

// CNSmlNotepadDataStore::NewL

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

CNSmlNotepadDataStore* CNSmlNotepadDataStore::NewL()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::NewL: BEGIN");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self); // self

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::NewL: END");

	return self;

	}

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

// CNSmlNotepadDataStore::~CNSmlNotepadDataStore()

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

CNSmlNotepadDataStore::~CNSmlNotepadDataStore()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::~CNSmlNotepadDataStore(): begin");

	if(iOwnStoreFormat)

	    {

		delete iOwnStoreFormat;

		iOwnStoreFormat = NULL;

	    }

	if(iDefaultStoreName)

	    {

		delete iDefaultStoreName;

		iDefaultStoreName = NULL;

	    }

	if(iNpdDb)

	    {

		delete iNpdDb;

		iNpdDb = NULL;

	    }

	if(iReplacedUids)

	    {

		delete iReplacedUids;

		iReplacedUids = NULL;

	    }

	if(iMovedUids)

	    {

		delete iMovedUids;

		iMovedUids = NULL;

	    }

	if(iSoftDeletedUids)

	    {

		delete iSoftDeletedUids;

		iSoftDeletedUids = NULL;

	    }

	if(iDeletedUids)

	    {

		delete iDeletedUids;

		iDeletedUids = NULL;

	    }

	if(iNewUids)

	    {

		delete iNewUids;

		iNewUids = NULL;

	    }

	iRfs.Close();

	iStringPool.Close();

	if(iOpenedStoreName)

	    {

		delete iOpenedStoreName;

		iOpenedStoreName = NULL;

	    }

	if(iItemData)

	    {

		delete iItemData;

		iItemData = NULL;	

	    }

	if ( iChangeFinder )

		{

		TRAP_IGNORE( iChangeFinder->CloseL() );

		delete iChangeFinder;

		iChangeFinder = NULL;

		}

	if( iSnapshot )

	    {

        delete iSnapshot;

        iSnapshot = NULL;

	    }

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::~CNSmlNotepadDataStore(): end");		

	}

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

// CNSmlNotepadDataStore::CNSmlNotepadDataStore() 

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

CNSmlNotepadDataStore::CNSmlNotepadDataStore() : iOpenedStoreId(KNSmlNotepadAdapterImplUid),iKey( TKeyArrayFix( _FOFF( TNSmlSnapshotItem,ItemId() ),ECmpTInt ))

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::CNSmlNotepadDataStore(): begin");

	iSyncHistory = EFalse;

	iDataBaseOpened = EFalse;

	iReaderPosition = -1;

	iWriterPosition = -1;

	iModificationCount = KNSmlCompactAfterChanges;

	iState = ENSmlClosed;

	iSnapshotRegistered = EFalse;

	iDrive = -1;

	iReplaceItemId =  -1;

	iServerMaxObjectSize = 0; // Maximum size default value

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::CNSmlNotepadDataStore(): end");

	}

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

// CNSmlNotepadDataStore::ConstructL()

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

void CNSmlNotepadDataStore::ConstructL()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::ConstructL(): begin");

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

	iStringPool.OpenL();

	iUsedMimeType.Set( KMimePlainText() );

	iUsedMimeVersion.Set( KMimePlainTextVersion() );

	// Uid Sets

	if(iNewUids)

	    {

		delete iNewUids;

		iNewUids = NULL;

	    }

	iNewUids = new (ELeave) CNSmlDataItemUidSet();

	if(iDeletedUids)

	    {

		delete iDeletedUids;

		iDeletedUids = NULL;

	    }

	iDeletedUids = new (ELeave) CNSmlDataItemUidSet();

	if(iSoftDeletedUids)

	    {

		delete iSoftDeletedUids;

		iSoftDeletedUids = NULL;

	    }

	iSoftDeletedUids = new (ELeave) CNSmlDataItemUidSet();

	if(iMovedUids)

	    {

		delete iMovedUids;

		iMovedUids = NULL;

	    }

	iMovedUids = new (ELeave) CNSmlDataItemUidSet();

	if(iReplacedUids)

	    {

		delete iReplacedUids;

		iReplacedUids = NULL;

	    }

	iReplacedUids = new (ELeave) CNSmlDataItemUidSet();

	if(iNpdDb)

	    {

		delete iNpdDb;

		iNpdDb = NULL;

	    }

	iNpdDb = CNSmlNotepadDatabase::NewL();

	if(iDefaultStoreName)

	    {

		delete iDefaultStoreName;

		iDefaultStoreName = NULL;

	    }

	iDefaultStoreName = HBufC::NewL( KNSmlDefaultStoreNameMaxSize );

	TInt len = iDefaultStoreName->Length();

	TPtr obptr = iDefaultStoreName->Des();

	iNpdDb->GetDefaultDatastoreName(obptr);

	if(iOwnStoreFormat)

	    {

		delete iOwnStoreFormat;

		iOwnStoreFormat = NULL;

	    }

	iOwnStoreFormat = DoOwnStoreFormatL();

	iSnapshot = new (ELeave) CArrayFixSeg<TNSmlSnapshotItem>(KSnapshotGranularity);

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::ConstructL(): end");

	}

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

// void CNSmlNotepadDataStore::DefaultStoreNameL()

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

const TDesC& CNSmlNotepadDataStore::DefaultStoreNameL() const

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DefaultStoreNameL(): begin");

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DefaultStoreNameL(): end");

	if ( iDefaultStoreName )

        {

        return *iDefaultStoreName;

        }

	return KNullDesC;

	}

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

// CDesCArray* CNSmlNotepadDataStore::DoListStoresLC();

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

CDesCArray* CNSmlNotepadDataStore::DoListStoresLC()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoListStoresLC(): begin");

	CDesCArray* npdStores = iNpdDb->ListDatabasesL();

	CleanupStack::PushL( npdStores );

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoListStoresLC(): end");

	return npdStores;

	}

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

// void CNSmlNotepadDataStore::DoOpenL(const TDesC& 		  aStoreName, 

//									    MSmlSyncRelationship& aContext,

//									    TRequestStatus& 	  aStatus)

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

void CNSmlNotepadDataStore::DoOpenL( const TDesC& aStoreName, 

									MSmlSyncRelationship& aContext, 

									TRequestStatus& aStatus )

    {

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	if( iState != ENSmlClosed || iDataBaseOpened )

	    {

		User::RequestComplete( iCallerStatus, KErrInUse );	

		return;	

	    }

	if(aStoreName.Length()>0)

	    {

		if( RFs::CharToDrive(aStoreName[0], iDrive) != KErrNone )

            {

            RFs::CharToDrive( KNSmlDriveC()[0], iDrive );

            }	

	    }

	// Open the Database

	TInt err( KErrNone );

	TRAP(err,iNpdDb->OpenL( aStoreName ));

	if ( err )

        {

        User::RequestComplete( iCallerStatus, err );

        return;

        }

    if ( iOpenedStoreName )

        {

        delete iOpenedStoreName;

        iOpenedStoreName = NULL;

        }

    iOpenedStoreName = aStoreName.Alloc();

    iDataBaseOpened = ETrue;

	if ( iChangeFinder )

		{

		iChangeFinder->CloseL();

		delete iChangeFinder;

		iChangeFinder = NULL;

		}

	iChangeFinder = CNSmlChangeFinder::NewL( aContext, iKey, iSyncHistory, KNSmlNotepadAdapterImplUid );

	err = FetchModificationsL();

	iState = ENSmlOpenAndWaiting;	

	User::RequestComplete( iCallerStatus, err );

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoOpenL(): end");

}

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

// void CNSmlNotepadDataStore::DoCancelRequest()

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

void CNSmlNotepadDataStore::DoCancelRequest()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCancelRequest(): begin");

	if ( iState == ENSmlOpenAndWaiting )

        {

        iState = ENSmlClosed;

        }

    else

        {

        iState = ENSmlOpenAndWaiting;

        }

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCancelRequest(): NOT NEEDED end");

	}

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

// void CNSmlNotepadDataStore::DoStoreName()

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

const TDesC& CNSmlNotepadDataStore::DoStoreName() const

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoStoreName(): begin");

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoStoreName(): end");

	if ( iOpenedStoreName )

		{

        return *iOpenedStoreName;

		}

	return KNullDesC;

	}

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

// void CNSmlNotepadDataStore::DoBeginTransactionL()

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

void CNSmlNotepadDataStore::DoBeginTransactionL()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoBeginTransactionL(): begin");

	User::Leave( KErrNotSupported );

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoBeginTransactionL(): end");

	}

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

// void CNSmlNotepadDataStore::DoCommitTransactionL()

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

void CNSmlNotepadDataStore::DoCommitTransactionL(TRequestStatus& aStatus)

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCommitTransactionL(): begin");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCommitTransactionL(): end");

	}

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

// void CNSmlNotepadDataStore::DoRevertTransaction()

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

void CNSmlNotepadDataStore::DoRevertTransaction(TRequestStatus& aStatus)

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoRevertTransaction(): begin");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoRevertTransaction(): end");

	}

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

// void CNSmlNotepadDataStore::DoBeginBatchL()

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

void CNSmlNotepadDataStore::DoBeginBatchL()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoBeginBatchL(): begin");

	User::Leave( KErrNotSupported );

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoBeginBatchL(): end");

	}

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

// void CNSmlNotepadDataStore::DoCommitBatchL()

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

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

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCommitBatchL(): begin");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCommitBatchL(): end");

	}

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

// void CNSmlNotepadDataStore::DoCancelBatch()

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

void CNSmlNotepadDataStore::DoCancelBatch()

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCancelBatch(): begin");

	// Nothing to do

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCancelBatch(): end");

	}

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

// void CNSmlNotepadDataStore::DoSetRemoteStoreFormatL()

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

void CNSmlNotepadDataStore::DoSetRemoteStoreFormatL( const CSmlDataStoreFormat& aServerDataStoreFormat )

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoSetRemoteStoreFormatL(): begin");

	TBool foundMime = EFalse;

	// KErrNotSupported is returned if server does not support same mime type 

	// and same mime type version as Data Provider.

	TInt i=0;

	while( i< aServerDataStoreFormat.MimeFormatCount() && !foundMime )

		{

		if( iUsedMimeType.MatchF(aServerDataStoreFormat.MimeFormat(i).MimeType().DesC())      ==0 &&

		    iUsedMimeVersion.MatchF(aServerDataStoreFormat.MimeFormat(i).MimeVersion().DesC())==0 )

			{

			foundMime = ETrue;

			iServerMimeType    = aServerDataStoreFormat.MimeFormat(i).MimeType();

			iServerMimeVersion = aServerDataStoreFormat.MimeFormat(i).MimeVersion();

			}

		i++;

		}

	if( !foundMime )

		{

		_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoSetRemoteStoreFormatL(): SERVER MIMETYPE NOTSUPPORTED end");

		User::Leave( KErrNotSupported );

		}

	if( !iOwnStoreFormat )

		{

        iOwnStoreFormat = DoOwnStoreFormatL();

		}

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoSetRemoteStoreFormatL(): end");

	return;

	}

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

// void CNSmlNotepadDataStore::DoSetRemoteMaxObjectSize()

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

void CNSmlNotepadDataStore::DoSetRemoteMaxObjectSize( TInt aServerMaxObjectSize )

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoSetRemoteMaxObjectSize(): begin");

	iServerMaxObjectSize = aServerMaxObjectSize;

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoSetRemoteMaxObjectSize(): end");

	}	

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

// void CNSmlNotepadDataStore::DoMaxObjectSize()

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

TInt CNSmlNotepadDataStore::DoMaxObjectSize() const

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoMaxObjectSize(): begin");

	if ( iOwnStoreFormat )

		{

		if ( iOwnStoreFormat->HasMaxSize() )

			{

			_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoMaxObjectSize - From resource: END");

			return iOwnStoreFormat->MaxSize();

			}

		}

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoMaxObjectSize() 100 k: end");

	return KNSmlDataStoreMaxSize;  // 100 k

	}

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

// void CNSmlNotepadDataStore::DoOpenItemL()

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

void CNSmlNotepadDataStore::DoOpenItemL( TSmlDbItemUid aUid, 

										  TBool& aFieldChange, 

										  TInt& aSize, 

										  TSmlDbItemUid& aParent, 

										  TDes8& aMimeType, 

										  TDes8& aMimeVer, 

										  TRequestStatus& aStatus )

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoOpenItemL(): begin");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	if ( iState != ENSmlOpenAndWaiting )

		{

		User::RequestComplete( iCallerStatus, KErrNotReady );

		return;

		}

	aFieldChange = EFalse; // Whole item sent NOT SUPPORT ON FIELDCHANGE

	aMimeType    = iOwnStoreFormat->MimeFormat( 0 ).MimeType().DesC();

	aMimeVer	 = iOwnStoreFormat->MimeFormat( 0 ).MimeVersion().DesC();

	aParent      = KNullDataItemId;

	if( !iItemData )

		{

		iItemData= CBufFlat::NewL( KNSmlItemDataExpandSize );

		}

	else

		{

		iItemData->Reset();

		}

	TInt err = OpenItemL( aUid, *iItemData );

	if( !err )

		{

		iItemData->Compress();

		iReaderPosition  = 0;

		aSize = iItemData->Size();

		iState = ENSmlItemOpen;

		if ( iServerMaxObjectSize == 0 || aSize <= iServerMaxObjectSize )

			{

			User::RequestComplete( iCallerStatus, KErrNone );

			}

		else

			{

			User::RequestComplete( iCallerStatus, KErrTooBig );

			}

		}

	else

		{

		User::RequestComplete( iCallerStatus, err );

		}

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoOpenItemL(): end");

	}

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

// void CNSmlNotepadDataStore::DoCreateItemL()

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

void CNSmlNotepadDataStore::DoCreateItemL( TSmlDbItemUid& aUid, 

											TInt aSize, 

											TSmlDbItemUid /*aParent*/, 

											const TDesC8& aMimeType, 

											const TDesC8& aMimeVer, 

											TRequestStatus& aStatus )

	{

	_NOTEPAD_DBG_FILE("CNSmlNotepadDataStore::DoCreateItemL(): begin");

	TBuf8<255> lMimeType;

	lMimeType.Copy(aMimeType);

	TBuf8<255> lMimeVer;

	lMimeVer.Copy(aMimeVer);

	iCallerStatus = &aStatus;