/*

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

#include <DataSyncInternalPSKeys.h>

#include <CalenImporter.h>

#include <CalenInterimUtils2.h>

#include <utf.h>

#include <nsmldebug.h>

#include <nsmlagendaadapterhandler.h>

#include <calenmulticaluids.hrh>

#include <calenmulticalutil.h>

#include <nsmlconstants.h>

#include <centralrepository.h> 

#include "nsmlagendadebug.h"

#include "nsmlagendadatastore.h"

#include "nsmlagendadataprovider.h"

#include "nsmlchangefinder.h"

#include "NSmlDataModBase.h"

#include "nsmlagendadefines.hrh"

#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 ),

	iIsHierarchicalSyncSupported( EFalse ),

	iParentItemId( 0 ),

    iOrphanEvent( EFalse )

	{

	FLOG(_L("CNSmlAgendaDataStore::CNSmlAgendaDataStore(): BEGIN"));

	// RD_MULTICAL

	iDataMimeType = ENSmlNone;

	iAgendaAdapterHandler = NULL;

	// RD_MULTICAL

	FLOG(_L("CNSmlAgendaDataStore::CNSmlAgendaDataStore(): END"));

	}

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

// CNSmlAgendaDataStore::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNSmlAgendaDataStore::ConstructL()

	{

	FLOG(_L("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();

	iDefaultStoreFileName = HBufC::NewL( KNSmlDefaultStoreNameMaxSize );

	*iDefaultStoreFileName = KNSmlAgendaFileNameForDefaultDB; 

	// RD_MULTICAL

	iAgendaAdapterLog = NULL;

	iCalOffsetArr = new (ELeave) CArrayFixFlat<TUint>( KArrayGranularity );

	iCommittedUidArr = new ( ELeave ) CNSmlDataItemUidSet();

	//iCalOffsetVal = CCalenMultiCalUtil::GetOffsetL();

	// TODO: Tweak code: BEGIN

	iCalOffsetVal = 100000;	

	ListAllAgendaPluginAdaptersL();

	// END  

	iOwnFormat = DoOwnStoreFormatL();

	// RD_MULTICAL

	iDataMod->SetOwnStoreFormat( *iOwnFormat );	

    iInterimUtils = CCalenInterimUtils2::NewL();

    // Initialize the FieldId to a default value [UID3 of the application]

    // This value will be rewritten once the exact single CalendarDB is determined

    // In case of HF synchronization involving multiple CalendarDB's the below value 

    // will be retained.

    iOpenedStoreId = KNSmlAgendaAdapterUid;

	FLOG(_L("CNSmlAgendaDataStore::ConstructL: END"));

	}

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

// CNSmlAgendaDataStore::NewL

// Two-phased constructor.

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

//

CNSmlAgendaDataStore* CNSmlAgendaDataStore::NewL()

	{

	FLOG(_L("CNSmlAgendaDataStore::NewL: BEGIN"));

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	FLOG(_L("CNSmlAgendaDataStore::NewL: END"));

	return self;

	}

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

// CNSmlAgendaDataStore::~CNSmlAgendaDataStore

// Destructor.

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

//

CNSmlAgendaDataStore::~CNSmlAgendaDataStore()

	{

	FLOG(_L("CNSmlAgendaDataStore::~CNSmlAgendaDataStore(): BEGIN"));

    // Enable notifications

    TInt error( KErrNone );

    // TODO:

    /*if ( iVCalSession )

        {

        TRAP_IGNORE( iVCalSession->EnablePubSubNotificationsL() );

        TRAP_IGNORE( iVCalSession->EnableChangeBroadcast() );

        }*/  

    if ( iChangeFinder )

		{

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

		}

    delete iChangeFinder;

	delete iNewUids;

	delete iDeletedUids;

	delete iSoftDeletedUids;

	delete iMovedUids;

	delete iReplacedUids;

    delete iDefaultStoreFileName;

    delete iOpenedStoreName;

    delete iReceivedStoreName;

	delete iDataMod;

	delete iItemData;

    delete iInterimUtils;

    iAgendaPluginAdapters.ResetAndDestroy();    

    if( iOwnFormat )

       {

       delete iOwnFormat;

       iOwnFormat = NULL;

       }

    iRfs.Close();

    iStringPool.Close();

    if ( iCalOffsetArr )

       {

       iCalOffsetArr->Reset();

       delete iCalOffsetArr;

       }

    if ( iCommittedUidArr )

       {

       iCommittedUidArr->Reset();

       delete iCommittedUidArr;

       }

	FLOG(_L("CNSmlAgendaDataStore::~CNSmlAgendaDataStore(): END"));

	}

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

// CNSmlAgendaDataStore::DoOpenL

// Open calendar database for access.

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

//

void CNSmlAgendaDataStore::DoOpenL( const TDesC& aStoreName,

                MSmlSyncRelationship& aContext, TRequestStatus& aStatus )

    {

	FLOG(_L("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 );

		}

	if ( iReceivedStoreName )

        {

        delete iReceivedStoreName;

        iReceivedStoreName = NULL;

        } 

	iReceivedStoreName = aStoreName.AllocL();

    // Open database

	TInt err( KErrNone );	

	if ( aStoreName == KNSmlAgendaFileNameForDefaultDB )

		{

		FLOG(_L("CNSmlAgendaDataStore::DoOpenL: Calling the OpenStoreL: '%S'"), &aStoreName);

		TRAP( err, OpenStoreL() );

		}    

	if ( err )

	    {

	    User::RequestComplete( iCallerStatus, err );

	    return;

	    }

	if ( iChangeFinder )

		{

		iChangeFinder->CloseL();

		delete iChangeFinder;

		iChangeFinder = NULL;

		}

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

	                                         KNSmlAgendaAdapterImplUid );

	iAgendaAdapterLog = CNSmlAgendaAdapterLog::NewL( aContext );

	iState = ENSmlOpenAndWaiting;

    User::RequestComplete( iCallerStatus, err );

	FLOG(_L("CNSmlAgendaDataStore::DoOpenL: END"));

    }

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

// CNSmlAgendaDataStore::DoCancelRequest

// Set internal module state to previous state.

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

//

void CNSmlAgendaDataStore::DoCancelRequest()

    {

	FLOG(_L("CNSmlAgendaDataStore::DoCancelRequest: BEGIN"));

    if ( iState == ENSmlOpenAndWaiting )

        {

    	iState = ENSmlClosed;

        }

    else

        {

	    iState = ENSmlOpenAndWaiting;

        }

	FLOG(_L("CNSmlAgendaDataStore::DoCancelRequest: END"));

    }

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

// CNSmlAgendaDataStore::DoStoreName

// Returns previously opened database name.

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

//

const TDesC& CNSmlAgendaDataStore::DoStoreName() const

    {

	FLOG(_L("CNSmlAgendaDataStore::DoStoreName: BEGIN"));

	FLOG(_L("CNSmlAgendaDataStore::DoStoreName: END"));

	return *iReceivedStoreName;

    }

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

// CNSmlAgendaDataStore::DoBeginTransactionL

// Not supported.

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

//

void CNSmlAgendaDataStore::DoBeginTransactionL()

    {

	FLOG(_L("CNSmlAgendaDataStore::DoBeginTransactionL: BEGIN"));

	User::Leave( KErrNotSupported );

	FLOG(_L("CNSmlAgendaDataStore::DoBeginTransactionL: END"));

    }

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

// CNSmlAgendaDataStore::DoCommitTransactionL

// Not supported.

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

//

void CNSmlAgendaDataStore::DoCommitTransactionL( TRequestStatus& aStatus )

    {

	FLOG(_L("CNSmlAgendaDataStore::DoCommitTransactionL: BEGIN"));

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	FLOG(_L("CNSmlAgendaDataStore::DoCommitTransactionL: END"));

    }

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

// CNSmlAgendaDataStore::DoRevertTransaction

// Not supported.

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

//

void CNSmlAgendaDataStore::DoRevertTransaction( TRequestStatus& aStatus )

    {

	FLOG(_L("CNSmlAgendaDataStore::DoRevertTransaction: BEGIN"));

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	FLOG(_L("CNSmlAgendaDataStore::DoRevertTransaction: END"));

    }

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

// CNSmlAgendaDataStore::DoBeginBatchL

// Not supported.

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

//

void CNSmlAgendaDataStore::DoBeginBatchL()

    {

	FLOG(_L("CNSmlAgendaDataStore::DoBeginBatchL: BEGIN"));

	User::Leave( KErrNotSupported );

	FLOG(_L("CNSmlAgendaDataStore::DoBeginBatchL: END"));

    }

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

// CNSmlAgendaDataStore::DoCommitBatchL

// Not supported.

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

//

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

                TRequestStatus& aStatus )

    {

	FLOG(_L("CNSmlAgendaDataStore::DoCommitBatchL: BEGIN"));

	iCallerStatus = &aStatus;

	*iCallerStatus = KRequestPending;

	User::RequestComplete( iCallerStatus, KErrNotSupported );

	FLOG(_L("CNSmlAgendaDataStore::DoCommitBatchL: END"));

    }

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

// CNSmlAgendaDataStore::DoCancelBatch

// Not supported.

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

//

void CNSmlAgendaDataStore::DoCancelBatch()

    {

	FLOG(_L("CNSmlAgendaDataStore::DoCancelBatch: BEGIN"));

	// Nothing to do

	FLOG(_L("CNSmlAgendaDataStore::DoCancelBatch: END"));

    }

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

// CNSmlAgendaDataStore::DoSetRemoteStoreFormatL

// Set SyncML Remote Server data store format.

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

//

void CNSmlAgendaDataStore::DoSetRemoteStoreFormatL(

                const CSmlDataStoreFormat& aServerDataStoreFormat )

    {

	FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: BEGIN"));

	if ( iOwnFormat )

	    {

	    delete iOwnFormat;

	    iOwnFormat = NULL;    

	    }

	iOwnFormat = DoOwnStoreFormatL();

	// RD_MULTICAL

	if ( aServerDataStoreFormat.IsSupported( 

	                                CSmlDataStoreFormat::EOptionHierarchial ) )

        {

        FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Supports HIERARCHIAL"));

        iIsHierarchicalSyncSupported = ETrue;

		// Check what properties are supported for folders

        iAgendaAdapterHandler->CheckServerSupportForFolder( aServerDataStoreFormat );

        }

	else

	    {

	    FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Do not support HIERARCHIAL"));	           

	    iIsHierarchicalSyncSupported = EFalse;

	    }

	// RD_MULTICAL       

	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

    FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Support iCal"));

   	returnValue = iDataMod->SetUsedMimeType(

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

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

#endif // __NSML_USE_ICAL_FEATURE

    if ( returnValue == KErrNone )

        {

        FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Sets iCal"));

        iRXEntryType = ENSmlICal;

        iTXEntryType = ENSmlICal;

        }

    else

        {

        FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Support vCal"));

        returnValue = iDataMod->SetUsedMimeType(

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

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

        if ( returnValue == KErrNone )

            {

            FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: Sets vCal"));

            iRXEntryType = ENSmlVCal;

            iTXEntryType = ENSmlVCal;

            }

        }

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

        {

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

        FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: MimeType Not supported"));

        User::Leave( KErrNotFound );        

        }

    // RD_MULTICAL

    if( !iSnapshotRegistered )

        {

        RegisterSnapshotL();

        }

    // RD_MULTICAL

	FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteStoreFormatL: END"));

    }

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

// CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize

// Set SyncML Remote Server maximum object size.

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

//

void CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize( TInt aServerMaxObjectSize )

    {

	FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize: BEGIN"));

	iServerMaxObjectSize = aServerMaxObjectSize;

	FLOG(_L("CNSmlAgendaDataStore::DoSetRemoteMaxObjectSize: END"));

    }

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

// CNSmlAgendaDataStore::DoMaxObjectSize

// Set SyncML Component maximum object size.

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

//

TInt CNSmlAgendaDataStore::DoMaxObjectSize() const

    {

	FLOG(_L("CNSmlAgendaDataStore::DoMaxObjectSize: BEGIN"));

	FLOG(_L("CNSmlAgendaDataStore::DoMaxObjectSize - Default: END"));

	return KNSmlAgendaOwnMaxObjectSize;

    }

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

// CNSmlAgendaDataStore::DoOpenItemL

// Open calendar item for reading.

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

//

void CNSmlAgendaDataStore::DoOpenItemL( TSmlDbItemUid aUid,