/*

* 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 agenda data store

*

*/

// INCLUDES

#include "nsmldebug.h"

#include "nsmlagendadatastore.h"

#include "nsmlagendadataprovider.h"

#include "nsmlchangefinder.h"

#include "NSmlDataModBase.h"

#include "nsmlagendadefines.hrh"

#include <ecom.h>

#include <barsc.h>

#include <bautils.h>

#include <calsession.h> 

#include <caldataexchange.h> 

#include <calentryview.h>

#include <caliterator.h>

#include <calentry.h>

#include <caldataformat.h>

#include <caltime.h>

#include <nsmldsimpluids.h>

#include <sysutil.h>

#include <SmlDataProvider.h>

#include <SmlDataFormat.h>

#include <SmlDataSyncDefs.h>

#include <data_caging_path_literals.hrh>

#include <NSmlAgendaDataStore_1_1_2.rsg>

#include <NSmlAgendaDataStore_1_2.rsg>

#include <e32property.h>

#include <DataSyncInternalPSKeys.h>

#include <CalenImporter.h>

#include <CalenInterimUtils2.h>

#ifndef __WINS__

// This lowers the unnecessary compiler warning (armv5) to remark.

// "Warning:  #174-D: expression has no effect..." is caused by 

// DBG_ARGS8 macro in no-debug builds.

#pragma diag_remark 174

#endif

// ============================= MEMBER FUNCTIONS ==============================

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

// CNSmlAgendaDataStore::CNSmlAgendaDataStore

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

// might leave.

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

//

CNSmlAgendaDataStore::CNSmlAgendaDataStore() :

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

	iPos( -1 ),

	iHasHistory( EFalse ),

	iModificationCount( KNSmlCompactAfterChanges ),

	iState( ENSmlClosed ),

	iSnapshotRegistered( EFalse ),

	iDrive( -1 ),

	iReplaceItemId( -1 ),

	iRXEntryType( ENSmlNotSet ),

	iTXEntryType( ENSmlNotSet )

	{

	_DBG_FILE("CNSmlAgendaDataStore::CNSmlAgendaDataStore(): BEGIN");

	_DBG_FILE("CNSmlAgendaDataStore::CNSmlAgendaDataStore(): END");

	}

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

// CNSmlAgendaDataStore::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNSmlAgendaDataStore::ConstructL()

	{

	_DBG_FILE("CNSmlAgendaDataStore::ConstructL: BEGIN");

	iStringPool.OpenL();

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

	iDataMod = new ( ELeave ) CNSmlVCalMod();

	iNewUids = new ( ELeave ) CNSmlDataItemUidSet();

	iDeletedUids = new ( ELeave ) CNSmlDataItemUidSet();

	iSoftDeletedUids = new ( ELeave ) CNSmlDataItemUidSet();

	iMovedUids = new ( ELeave ) CNSmlDataItemUidSet();

	iReplacedUids = new ( ELeave ) CNSmlDataItemUidSet();

	iDefaultStoreName = HBufC::NewL( KNSmlDefaultStoreNameMaxSize );

	iVersitTlsData = &CVersitTlsData::VersitTlsDataL();

	// Create CalSession and CalEntryView instances

	iVCalSession = CCalSession::NewL();

	TPtr obptr = iDefaultStoreName->Des();

	obptr = iVCalSession->DefaultFileNameL(); 

	iOwnFormat = DoOwnStoreFormatL();

	iDataMod->SetOwnStoreFormat( *iOwnFormat );

    iInterimUtils = CCalenInterimUtils2::NewL();

	_DBG_FILE("CNSmlAgendaDataStore::ConstructL: END");

	}

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

// CNSmlAgendaDataStore::NewL

// Two-phased constructor.

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

//

CNSmlAgendaDataStore* CNSmlAgendaDataStore::NewL()

	{

	_DBG_FILE("CNSmlAgendaDataStore::NewL: BEGIN");

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	_DBG_FILE("CNSmlAgendaDataStore::NewL: END");

	return self;

	}

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

// CNSmlAgendaDataStore::~CNSmlAgendaDataStore

// Destructor.

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

//

CNSmlAgendaDataStore::~CNSmlAgendaDataStore()

	{

	_DBG_FILE("CNSmlAgendaDataStore::~CNSmlAgendaDataStore(): BEGIN");

    // Enable notifications

    TInt error( KErrNone );

    if ( iVCalSession )

        {

        TRAP_IGNORE( iVCalSession->EnablePubSubNotificationsL() );

        TRAP_IGNORE( iVCalSession->EnableChangeBroadcast() );

        }

	delete iOwnFormat;

	iRfs.Close();

	iStringPool.Close();

    if ( iChangeFinder )

		{

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

		}

	if (iVersitTlsData)

			{

			iVersitTlsData->VersitTlsDataClose();

			}

	delete iChangeFinder;

	delete iNewUids;

	delete iDeletedUids;

	delete iSoftDeletedUids;

	delete iMovedUids;

	delete iReplacedUids;

    delete iDefaultStoreName;

    delete iOpenedStoreName;

	delete iDataMod;

	delete iItemData;

    delete iAgendaProgressview;

	delete iImporter;

    delete iExporter;

    delete iEntryView;

    delete iVCalSession;

    delete iInterimUtils;

    // REComSession::FinalClose();

	_DBG_FILE("CNSmlAgendaDataStore::~CNSmlAgendaDataStore(): END");

	}

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

// CNSmlAgendaDataStore::DoOpenL

// Open calendar database for access.

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

//

void CNSmlAgendaDataStore::DoOpenL( const TDesC& aStoreName,

                MSmlSyncRelationship& aContext, TRequestStatus& aStatus )

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoOpenL: BEGIN");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	if ( iState != ENSmlClosed )

		{

		User::RequestComplete( iCallerStatus, KErrInUse );

		return;

		}

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

		{

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

		}

    // Open database

	TInt err( KErrNone );	

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

	DBG_ARGS(_S("CNSmlAgendaDataStore::DoOpenL: error while opening '%d'"), err );

	if( err == KErrNotFound )

        {

        err = KErrNone;

        TRAP( err, iVCalSession->CreateCalFileL( aStoreName ));

        DBG_ARGS(_S("CNSmlAgendaDataStore::DoOpenL: creating the new calfile '%d'"), err );

        }

	if ( err )

	    {

	    User::RequestComplete( iCallerStatus, err );

	    return;

	    }

	// Disable notifications

	TRAP_IGNORE( iVCalSession->DisablePubSubNotificationsL() );

	TRAP_IGNORE( iVCalSession->DisableChangeBroadcast() );

	if ( iOpenedStoreName )

		{

		delete iOpenedStoreName;

		iOpenedStoreName = NULL;

		}

	iOpenedStoreName = aStoreName.AllocL();

	// Initialize some member variables

	// Create importer and exporter

    iImporter = CCalenImporter::NewL( *iVCalSession );

	iExporter = CCalenExporter::NewL( *iVCalSession );

    // Progress view

	iAgendaProgressview = CNSmlAgendaProgressview::NewL();

    iEntryView = CCalEntryView::NewL( *iVCalSession, *iAgendaProgressview );

    CActiveScheduler::Start();

    TInt completedStatus = iAgendaProgressview->GetCompletedStatus();

    if ( completedStatus != KErrNone )

        {

        User::RequestComplete( iCallerStatus, completedStatus );

        return;

        }

	if ( iChangeFinder )

		{

		iChangeFinder->CloseL();

		delete iChangeFinder;

		iChangeFinder = NULL;

		}

	iChangeFinder = CNSmlChangeFinder::NewL( aContext, iKey, iHasHistory,

	                                         KNSmlAgendaAdapterImplUid );

    // Get ID of database

	iVCalSession->FileIdL( iOpenedStoreId );

	if( !iSnapshotRegistered )

		{

		RegisterSnapshotL();

		}

	iState = ENSmlOpenAndWaiting;

    User::RequestComplete( iCallerStatus, err );

	_DBG_FILE("CNSmlAgendaDataStore::DoOpenL: END");

    }

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

// CNSmlAgendaDataStore::DoCancelRequest

// Set internal module state to previous state.

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

//

void CNSmlAgendaDataStore::DoCancelRequest()

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoCancelRequest: BEGIN");

    if ( iState == ENSmlOpenAndWaiting )

        {

    	iState = ENSmlClosed;

        }

    else

        {

	    iState = ENSmlOpenAndWaiting;

        }

	_DBG_FILE("CNSmlAgendaDataStore::DoCancelRequest: END");

    }

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

// CNSmlAgendaDataStore::DoStoreName

// Returns previously opened database name.

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

//

const TDesC& CNSmlAgendaDataStore::DoStoreName() const

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoStoreName: BEGIN");

	_DBG_FILE("CNSmlAgendaDataStore::DoStoreName: END");

	return *iOpenedStoreName;

    }

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

// CNSmlAgendaDataStore::DoBeginTransactionL

// Not supported.

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

//

void CNSmlAgendaDataStore::DoBeginTransactionL()

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoBeginTransactionL: BEGIN");

	User::Leave( KErrNotSupported );

	_DBG_FILE("CNSmlAgendaDataStore::DoBeginTransactionL: END");

    }

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

// CNSmlAgendaDataStore::DoCommitTransactionL

// Not supported.

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

//

void CNSmlAgendaDataStore::DoCommitTransactionL( TRequestStatus& aStatus )

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoCommitTransactionL: BEGIN");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	_DBG_FILE("CNSmlAgendaDataStore::DoCommitTransactionL: END");

    }

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

// CNSmlAgendaDataStore::DoRevertTransaction

// Not supported.

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

//

void CNSmlAgendaDataStore::DoRevertTransaction( TRequestStatus& aStatus )

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoRevertTransaction: BEGIN");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	_DBG_FILE("CNSmlAgendaDataStore::DoRevertTransaction: END");

    }

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

// CNSmlAgendaDataStore::DoBeginBatchL

// Not supported.

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

//

void CNSmlAgendaDataStore::DoBeginBatchL()

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoBeginBatchL: BEGIN");

	User::Leave( KErrNotSupported );

	_DBG_FILE("CNSmlAgendaDataStore::DoBeginBatchL: END");

    }

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

// CNSmlAgendaDataStore::DoCommitBatchL

// Not supported.

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

//

void CNSmlAgendaDataStore::DoCommitBatchL( RArray<TInt>& /*aResultArray*/,

                TRequestStatus& aStatus )

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoCommitBatchL: BEGIN");

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	_DBG_FILE("CNSmlAgendaDataStore::DoCommitBatchL: END");

    }

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

// CNSmlAgendaDataStore::DoCancelBatch

// Not supported.

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

//

void CNSmlAgendaDataStore::DoCancelBatch()

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoCancelBatch: BEGIN");

	// Nothing to do

	_DBG_FILE("CNSmlAgendaDataStore::DoCancelBatch: END");

    }

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

// CNSmlAgendaDataStore::DoSetRemoteStoreFormatL

// Set SyncML Remote Server data store format.

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

//

void CNSmlAgendaDataStore::DoSetRemoteStoreFormatL(

                const CSmlDataStoreFormat& aServerDataStoreFormat )

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: BEGIN");

	if ( iOwnFormat )

	    {

	    delete iOwnFormat;

	    iOwnFormat = NULL;    

	    }

	iOwnFormat = DoOwnStoreFormatL();

	iDataMod->SetOwnStoreFormat( *iOwnFormat );

    iDataMod->SetPartnerStoreFormat( ( CSmlDataStoreFormat& )

                aServerDataStoreFormat );

    // Check which calendar type (vCal/iCal) is used

    // If server supports iCal then it is used

    // Otherwise vCal is used

    TInt returnValue( KErrNotSupported );

#ifdef __NSML_USE_ICAL_FEATURE

    _DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Support iCal");

   	returnValue = iDataMod->SetUsedMimeType(

       	    iOwnFormat->MimeFormat( 1 ).MimeType(),

           	iOwnFormat->MimeFormat( 1 ).MimeVersion() );

#endif // __NSML_USE_ICAL_FEATURE

    if ( returnValue == KErrNone )

        {

        _DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Sets iCal");

        iRXEntryType = ENSmlICal;

        iTXEntryType = ENSmlICal;

        }

    else

        {

        _DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Support vCal");

        returnValue = iDataMod->SetUsedMimeType(

            iOwnFormat->MimeFormat( 0 ).MimeType(),

            iOwnFormat->MimeFormat( 0 ).MimeVersion() );

        if ( returnValue == KErrNone )

            {

            _DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Sets vCal");

            iRXEntryType = ENSmlVCal;

            iTXEntryType = ENSmlVCal;

            }

        }

    if ( iRXEntryType == ENSmlNotSet || iTXEntryType == ENSmlNotSet )

        {

        // Leave if server does not support either vCal or iCal

        _DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: MimeType Not supported");

        User::Leave( KErrNotFound );        

        }

	_DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: END");

    }

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

// CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize

// Set SyncML Remote Server maximum object size.

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

//

void CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize( TInt aServerMaxObjectSize )

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize: BEGIN");

	iServerMaxObjectSize = aServerMaxObjectSize;

	_DBG_FILE("CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize: END");

    }

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

// CNSmlAgendaDataStore::DoMaxObjectSize

// Set SyncML Component maximum object size.

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

//

TInt CNSmlAgendaDataStore::DoMaxObjectSize() const

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoMaxObjectSize: BEGIN");

	_DBG_FILE("CNSmlAgendaDataStore::DoMaxObjectSize - Default: END");

	return KNSmlAgendaOwnMaxObjectSize;

    }

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

// CNSmlAgendaDataStore::DoOpenItemL

// Open calendar item for reading.

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

//

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

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

                TDes8& aMimeVer, TRequestStatus& aStatus )

    {

	_DBG_FILE("CNSmlAgendaDataStore::DoOpenItemL: BEGIN");

    iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	if ( iState != ENSmlOpenAndWaiting )

		{

		User::RequestComplete( iCallerStatus, KErrNotReady );

		return;

		}

 	iReplaceItemId = aUid;

	CCalEntry* entry = NULL;

	TInt err( KErrNone );

    TRAP( err, entry = iEntryView->FetchL( aUid ) );

	CleanupStack::PushL( entry );

	if ( err || !entry )

		{

		CleanupStack::PopAndDestroy( entry ); // entry

		User::RequestComplete( iCallerStatus, KErrNotFound );

		return;

		}

	if ( !iSnapshotRegistered )

		{

		RegisterSnapshotL();

		}

	delete iItemData;

	iItemData = NULL;