/*

* 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 Sync flow

*

*/

#define SYNCML_V3

// INCLUDE FILES

#include <SyncMLObservers.h>

#include <SyncMLNotifierParams.h>

#include <SyncMLNotifier.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmlphoneinfo.h>

#include <nsmlunicodeconverter.h>

#include <centralrepository.h>

// common includes with DM

#include "nsmlcliagconstants.h"

#include "NSmlCmdsBase.h"

#include "NSmlAgentBase.h"

#include "NSmlStatusContainer.h"

#include "NSmlResponseController.h"

#include "NSmlURI.h"

#include "WBXMLSyncMLGenerator.h"

#include "WBXMLSyncMLParser.h"

#include "WBXMLDevInfGenerator.h"

#include "WBXMLDevInfParser.h"

#include "WBXMLGeneratorError.h"

#include "WBXMLParser.h"

#include "WBXMLParserError.h"

#include "smldtd.h"

#include "smldef.h"

// DS specific includes

#include "nsmldsagconstants.h"

#include "NSmlDSCmds.h"

#include "nsmldscontent.h"

#include "NSmlDSAgent.h"

#include "nsmldserror.h"

#include "nsmlfilter.h"

#include "nsmldssettings.h"

#include "nsmldsbatchbuffer.h"

#include "nsmldshostclient.h"

#include "nsmloperatordefines.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

// CONSTANTS

_LIT8( KNSmlRoot, "/" );

static const TInt KMaxLength = 255;

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

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

// CNSmlDSCmds::CNSmlDSCmds()

// C++ default constructor.

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

//

CNSmlDSCmds::CNSmlDSCmds( CNSmlDSContent& aDSContent, MSyncMLProgressObserver& aDSObserver ) : iDSContent( aDSContent ), iDSObserver( aDSObserver )

    {

    iAtomicModeOn = EFalse;

    iAtomicId = 0;

    iAtomicHasFailed = EFalse;

    iItemOpened = EFalse;

	}

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

// CNSmlDSCmds::ConstructL

// Symbian 2nd phase constructor. 

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

//

void CNSmlDSCmds::ConstructL( CNSmlAgentBase* aAgent, const TDesC8& aSessionID, const TDesC8& aVerProto, const TInt aPublicId, const HBufC& aSyncMLUserName, CNSmlURI* aSyncServer, TBool aVersionCheck )

    {

	CNSmlCmdsBase::ConstructL( aAgent, aSessionID, aVerProto, aPublicId, aSyncMLUserName, aSyncServer, aVersionCheck );

    }

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

// CNSmlDSCmds::NewL

// Two-phased constructor.

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

//

CNSmlDSCmds* CNSmlDSCmds::NewL( CNSmlAgentBase* aAgent, const TDesC8& aSessionID, const TDesC8& aVerProto, const TInt aPublicId, const HBufC& aSyncMLUserName, CNSmlURI* aSyncServer, CNSmlDSContent& aDSContent, MSyncMLProgressObserver& aDSObserver, TBool aVersionCheck )

    {

	CNSmlDSCmds* self = new ( ELeave ) CNSmlDSCmds( aDSContent, aDSObserver );

	CleanupStack::PushL( self );

    self->ConstructL( aAgent, aSessionID, aVerProto, aPublicId, aSyncMLUserName, aSyncServer, aVersionCheck );

    CleanupStack::Pop();  // self

	return self;

    }

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

// CNSmlDSCmds::~CNSmlDSCmds

// Destructor.

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

//

CNSmlDSCmds::~CNSmlDSCmds()

    {

	delete iBatchBuffer;	

	delete iDSGetCmdId;

	delete iDSGetMsgId;

	delete iDSLargeObjectCmdName;

	delete iDSDevGenerator;

	delete iDSPreviousSyncTargetURI;

	delete iDataBuffer;	

	delete iLargeUid;

	}

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

// CNSmlDSCmds::CommitBatchL

// Commits the batched commands and sets their statuses.

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

//

void CNSmlDSCmds::CommitBatchL()

	{

	_DBG_FILE(_S8("CNSmlDSCmds::CommitBatchL : Begin"));

	if ( !iDSContent.BatchModeOn() )

		{

		return;

		}

	RArray<TInt> commitResults;

	TInt resultCode;

	iDSContent.CommitBatchL( commitResults, resultCode );

	// if the atomic mode is on and committing the batch fails then everyting will be rolled back

	if ( iAtomicModeOn && resultCode != KErrNone )	

		{

		iAtomicHasFailed = ETrue;

		commitResults.Close();

		iBatchModeOn = EFalse;

		delete iBatchBuffer;

		iBatchBuffer = NULL;

		return;

		}

	TInt commitIndex( 0 );

	for ( TInt batchIndex = 0; batchIndex < iBatchBuffer->Count(); batchIndex++ )

		{

		if ( resultCode != KErrNone )

			{

			iDSContent.IncreaseServerItemsFailed();

			iStatusToServer->SetStatusCodeL( iBatchBuffer->StatusEntryId( batchIndex ), TNSmlError::ESmlStatusCommandFailed );

			continue;

			}

		TInt statusId( KErrNone );

		for ( TInt i = 0; i < iBatchBuffer->NumberOfResults( batchIndex ); i++ )

			{

			if ( commitResults[commitIndex] != KErrNone )

				{

				statusId = commitResults[commitIndex];

				}

			++commitIndex;

			}

		// map the status code & set the command's status	

		MapStatusCodeL( batchIndex, statusId );

		if ( statusId != KErrNone )

			{

			iStatusToServer->SetStatusCodeL( iBatchBuffer->StatusEntryId( batchIndex ), iBatchBuffer->Status( batchIndex ) );

			}

		}

	iBatchModeOn = EFalse;

	delete iBatchBuffer;

	iBatchBuffer = NULL;

	_DBG_FILE(_S8("CNSmlDSCmds::CommitBatchL : End"));

	commitResults.Close();

	}

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

// CNSmlDSCmds::MapStatusCode

// Performs mapping between datastore operation return values and SyncML error

// codes.

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

//

void CNSmlDSCmds::MapStatusCodeL( const TInt aIndex, const TInt aStatus )

	{

	TBool commandOk( EFalse );

	if ( iBatchBuffer->Command( aIndex ) == KNSmlAgentAdd )

		{

		switch ( aStatus )

			{

			case KErrNone:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusItemAdded );

				iDSContent.IncreaseServerItemsAdded();

				commandOk = ETrue;

				if ( !iAtomicModeOn )

					{

					iDSContent.CreateNewMapItemL( iBatchBuffer->Uid( aIndex ), iBatchBuffer->GUid( aIndex ), 0 );

					}

				else

					{

					iDSContent.CreateNewMapItemL( iBatchBuffer->Uid( aIndex ), iBatchBuffer->GUid( aIndex ), iAtomicId );

					}

				break;

			case KErrDiskFull:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusDeviceFull );

				iAgent->InterruptL( iDSContent.CurrentIndex(), TNSmlError::ESmlLowMemory, EFalse, EFalse );

				break;

			case KErrNotSupported:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusUnsupportedMediaTypeOrFormat );

				break;

			default:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusCommandFailed );

				break;

			}

		}

	else if ( iBatchBuffer->Command( aIndex ) == KNSmlAgentReplace )

		{

		switch ( aStatus )

			{

			case KErrNone:			

				iDSContent.IncreaseServerItemsChanged();				

				commandOk = ETrue;

				break;

			case KErrNotFound:

				{

				TSmlDbItemUid newLUid;

				TInt retval = iDSContent.CreateItemL( newLUid, 

													  iBatchBuffer->ItemData( aIndex ).Size(), 

													  iBatchBuffer->MimeType( aIndex ), 

													  iBatchBuffer->MimeVersion( aIndex ),

													  iBatchBuffer->Parent( aIndex ) );

				if ( retval == KErrNone )

					{

					TRAP( retval, iDSContent.WriteItemL( iBatchBuffer->ItemData( aIndex ) ) );

					}

				if ( retval == KErrNone )

					{

					retval = iDSContent.CommitItemL();

					}

				switch( retval )

					{

					case KErrNone:

						iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusItemAdded );

						iDSContent.IncreaseServerItemsAdded();

						commandOk = ETrue;

						if ( !iAtomicModeOn )

							{

							iDSContent.CreateNewMapItemL( newLUid, iBatchBuffer->GUid( aIndex ), 0 );

							}

						else

							{

							iDSContent.CreateNewMapItemL( newLUid, iBatchBuffer->GUid( aIndex ), iAtomicId );

							}

						break;

					case KErrDiskFull:

						iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusDeviceFull );

						iAgent->InterruptL( iDSContent.CurrentIndex(), TNSmlError::ESmlLowMemory, EFalse, EFalse );

						break;

					case KErrNotSupported:

						iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusUnsupportedMediaTypeOrFormat );

						break;

					default:

						iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusCommandFailed );

						break;

					}

				}

				break;

			case KErrDiskFull:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusDeviceFull );

				iAgent->InterruptL( iDSContent.CurrentIndex(), TNSmlError::ESmlLowMemory, EFalse, EFalse );

				break;

			case KErrNotSupported:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusUnsupportedMediaTypeOrFormat );

				break;

			default:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusCommandFailed );

				break;

			}

		}

	else if ( iBatchBuffer->Command( aIndex ) == KNSmlAgentDelete )

		{

		switch ( aStatus )

			{

			case KErrNone:

				iDSContent.IncreaseServerItemsDeleted();

				commandOk = ETrue;

				break;

			case KErrNotFound:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusItemIsNotDeleted );

				break;

			case KErrDiskFull:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusDeviceFull );

				iAgent->InterruptL( iDSContent.CurrentIndex(), TNSmlError::ESmlLowMemory, EFalse, EFalse );

				break;

			case KErrNotSupported:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusUnsupportedMediaTypeOrFormat );

				break;

			default:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusCommandFailed );

				break;

			}

		}

	else if ( iBatchBuffer->Command( aIndex ) == KNSmlAgentMove )

		{

		switch ( aStatus )

			{

			case KErrNone:

				iDSContent.IncreaseServerItemsMoved();

				commandOk = ETrue;

				break;

			case KErrDiskFull:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusDeviceFull );

				iAgent->InterruptL( iDSContent.CurrentIndex(), TNSmlError::ESmlLowMemory, EFalse, EFalse );

				break;

			case KErrNotSupported:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusUnsupportedMediaTypeOrFormat );

				break;

			default:

				iBatchBuffer->SetStatus( aIndex, TNSmlError::ESmlStatusMoveFailed );

				break;

			}

		}

	if ( !commandOk )

	    {

	    iDSContent.IncreaseServerItemsFailed();

	    }

	}

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

// CNSmlDSCmds::DoAlertL

// Makes an Alert element and calls the parser to generate XML.

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

//

void CNSmlDSCmds::DoAlertL( const TDesC8& aAlertCode, TTime* aLastSyncAnchor, TTime* aNextSyncAnchor )

	{

	SmlAlert_t* alert = new ( ELeave ) SmlAlert_t; 

	CleanupStack::PushL( alert );

	// element type

	alert->elementType = SML_PE_ALERT;

	// CmdID element

	DoCmdIdL( alert->cmdID );

	// Alert code to Data element 

	PcdataNewL ( alert->data, aAlertCode );

	alert->itemList = new ( ELeave ) SmlItemList_t;

	alert->itemList->item = new ( ELeave ) SmlItem_t;

	// Target and Source elements

	if ( aAlertCode == KNSmlDSAgentResultAlert || aAlertCode == KNSmlDSAgentNextMessage || aAlertCode == KNSmlDSAgentNoEndOfData )

		{

		DoTargetL( alert->itemList->item->target, iSentSyncHdrTarget->HostName() );

		DoSourceL( alert->itemList->item->source, iSentSyncHdrSource->HostName() );

		}

	else

		{

		DoTargetWithFilterL( alert->itemList->item->target, iDSContent.RemoteDatabase()->Database() );			

		DoSourceL( alert->itemList->item->source, iDSContent.LocalDatabase()->Database() ); 

		}

	// Anchor/Last and Anchor/Next in the Meta Element

	if ( aLastSyncAnchor && aNextSyncAnchor )

		{

		HBufC8* lastAnchor = HBufC8::NewLC( KNSmlDSAgentAnchorDateFormat.iTypeLength );

		HBufC8* nextAnchor = HBufC8::NewLC( KNSmlDSAgentAnchorDateFormat.iTypeLength );

		if ( *aLastSyncAnchor != TTime( 0 ) )

			{

			lastAnchor->Des().Format( KNSmlDSAgentAnchorDateFormat, 

										aLastSyncAnchor->DateTime().Year(),

										aLastSyncAnchor->DateTime().Month() + 1,

										aLastSyncAnchor->DateTime().Day() + 1,

										aLastSyncAnchor->DateTime().Hour(),

										aLastSyncAnchor->DateTime().Minute(),

										aLastSyncAnchor->DateTime().Second() );

			}

		if ( *aNextSyncAnchor != TTime( 0 ) )

			{

			nextAnchor->Des().Format(  KNSmlDSAgentAnchorDateFormat, 

										aNextSyncAnchor->DateTime().Year(),

										aNextSyncAnchor->DateTime().Month() + 1,

										aNextSyncAnchor->DateTime().Day() + 1,

										aNextSyncAnchor->DateTime().Hour(),

										aNextSyncAnchor->DateTime().Minute(),

										aNextSyncAnchor->DateTime().Second() );

			}

		if ( ( *aLastSyncAnchor != TTime( 0 ) ) || ( *aNextSyncAnchor != TTime( 0 ) ) )

			{

			SmlMetInfMetInf_t* metInf;

			DoMetInfLC( metInf ); 

			DoAnchorsL( *metInf, lastAnchor, nextAnchor );

			DoMetaL( alert->itemList->item->meta, metInf );

			CleanupStack::Pop(); // metInf

			}

		CleanupStack::PopAndDestroy( 2 ); // lastAnchor, nextAnchor

		}

	TInt ret( iGenerator->smlAlertCmd( alert) );

	if ( ret != KWBXMLGeneratorOk )

		{

		User::Leave( ret );

		}

	CleanupStack::PopAndDestroy(); // alert

	// save Status response information for response status controlling

	TInt respID( CreateAndInitResponseItemL( KNSmlAgentAlert ) );

	iResponseController->SetAppIndex( respID, iDSContent.CurrentIndex() );

	if ( aAlertCode >= KNSmlDSTwoWay && aAlertCode <= KNSmlDSRefreshFromServerByServer )

		{

		iResponseController->SetResponseDetail( respID, CNSmlResponseController::EResponseInitAlert );

		}

	}

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

// CNSmlDSCmds::DoPutL

// Inserts DevInfo into Put element and calls the WBXML generator.

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

//

void CNSmlDSCmds::DoPutL()

	{

	SmlPut_t* put = new ( ELeave )SmlPut_t; 

	CleanupStack::PushL( put );

	put->elementType = SML_PE_PUT;

	// CmdID element

	DoCmdIdL( put->cmdID );

	// Type element in Meta 

	SmlMetInfMetInf_t* metInf;

	DoMetInfLC( metInf ); 

	PcdataNewL( metInf->type, KNSmlDSAgentDeviceInfoContentType );

	DoMetaL( put->meta, metInf );

	CleanupStack::Pop(); // metinf

	// Item element

	put->itemList = new ( ELeave )SmlItemList_t;

	put->itemList->item = new ( ELeave )SmlItem_t;

	// Item/Source element

	if ( iVersionPublicId == KNSmlSyncMLPublicId )

		{

		DoSourceL( put->itemList->item->source, KNSmlDSAgentDeviceInfo11URI ); 

		PcdataNewL( put->itemList->item->data, DoDeviceInfoL( ETrue ) );

		}

	else if ( iVersionPublicId == KNSmlSyncMLPublicId12 )

		{

		DoSourceL( put->itemList->item->source, KNSmlDSAgentDeviceInfo12URI ); 

		PcdataNewL( put->itemList->item->data, DoDeviceInfoL() );

		} 

	// Device Info

	FreeDeviceInfo();

	TInt ret( iGenerator->smlPutCmd( put ) );

	if ( ret != KWBXMLGeneratorOk )

		{

		User::Leave( ret );

		}

	CleanupStack::PopAndDestroy(); // put

	//save Status response information for response status controlling

	CreateAndInitResponseItemL( KNSmlAgentPut );

	}

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

// CNSmlDSCmds::DoResultsL

// Generate Device Info to Results element and calls the WBXML generator.

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

//

CNSmlCmdsBase::TReturnValue CNSmlDSCmds::DoResultsL()

	{

	SmlResults_t* results = new ( ELeave ) SmlResults_t; 

	CleanupStack::PushL( results );

	results->elementType = SML_PE_RESULTS;