/*

* 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:  SyncML DM command handling 

*

*/

// INCLUDE FILES

//

#include <f32file.h>

#include <utf.h>

// FOTA

#include <DevManInternalCRKeys.h>

#include <featmgr.h>

// FOTA end

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmlphoneinfo.h>

#include <nsmlunicodeconverter.h>

// DM specific includes

#include <nsmldmconst.h>

#include <nsmldmmodule.h>

//For P&S keys

#include <e32property.h>

#include <e32math.h> 

#include "nsmldminternalpskeys.h"

// common includes with DS

#include "nsmlcliagconstants.h"

#include "NSmlCmdsBase.h"

#include "NSmlAgentBase.h"

#include "NSmlStatusContainer.h"

#include "NSmlResponseController.h"

#include "NSmlResultsContainer.h"

#include "NSmlAuth.h"

#include "NSmlURI.h"

#include "WBXMLSyncMLGenerator.h"

#include "WBXMLSyncMLParser.h"

#include "WBXMLGeneratorError.h"

#include "WBXMLParser.h"

#include "smldtd.h"

#include "smldef.h"

#include "nsmlagenttestdefines.h"

#include <hbdevicedialogsymbian.h>

#include <hbsymbianvariant.h>

// DM specific includes

#include "nsmldmagconstants.h"

#include "NSmlDMCmds.h"

#include "nsmldmerror.h"

#include <dmdevdialogclient.h>

#include "OnlineSupportLogger.h"

#ifdef __TEST_TREEMODULE

#include "nsmldmtestmodule.h"

#else

#include <nsmldmmodule.h>

#endif

#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

//const TUid KNSmlSyncDialogUid = { 0x101F876A };

// FOTA

const TInt KNSmlDmNoRequest = -1;

// FOTA end

_LIT8 ( KNSmlDMMetaTypeUserRequest, "org.openmobilealliance.dm.firmwareupdate.userrequest" );

_LIT8 ( KNSmlDMMetaFormatUserRequest, "chr" );

const TUid dmagentuid =

            {

            0x101F6DE5

            };

enum TSyncmlHbNotifierKeys 

		{

     EHbSOSNotifierKeyStatus = 11, // status set will complete the client subscribe

     EHbSOSNotifierKeyStatusReturn = 12, // Return the content of actual status value accepted from UI

     EHbDMSyncNotifierKeyStatus = 13,

     EHbDMSyncNotifierKeyStatusReturn = 14

		};

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

// CNSmlDMCmds::NewL()

// Creates new instance of CNSmlDMCmds 

// Does not leave instance pointer to CleanupStack.

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

//

CNSmlDMCmds* CNSmlDMCmds::NewL( CNSmlAgentBase* aAgent, const TDesC8& aSessionID, const TDesC8& aVerProto, const HBufC& aSyncMLUserName, CNSmlURI* aSyncServer, const TDesC& aDMServerId, MSyncMLProgressObserver* aDMObserver )

    {

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

	CleanupStack::PushL( self );

    self->ConstructL( aAgent, aSessionID, aVerProto, aSyncMLUserName, aSyncServer, aDMServerId, aDMObserver );

    CleanupStack::Pop(); //self

	return self;

    }

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

// CNSmlDMCmds::~CNSmlDMCmds()

// Destructor

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

//

CNSmlDMCmds::~CNSmlDMCmds()

    {

	delete iDMServerId;

	delete iDMModule;

	if ( iDMDevInfo )

		{

		delete iDMDevInfo->iFormat;

		delete iDMDevInfo->iType; 

		delete iDMDevInfo->iObject;

		delete iDMDevInfo;

		}

	delete iLargeObjectUri;

	if(iChunk.Handle())

	    {

	    iChunk.Close();

	    }

	// FOTA

	// uninitialize feature manager

	FeatureManager::UnInitializeLib();

	delete iRepository;

	//P&S key deletion,even fine if the key is not there

	RProperty::Delete( KPSUidNSmlDMSyncAgent,KNSmlDMCmdAddOnExistingNodeorLeafKey);	

	// FOTA end	

	}

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

// CNSmlDMCmds::CNSmlDMCmds()

// Constructor

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

//

CNSmlDMCmds::CNSmlDMCmds()

    {

	}

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

// CNSmlDMCmds::ConstructL()

// 

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

void CNSmlDMCmds::ConstructL( CNSmlAgentBase* aAgent, const TDesC8& aSessionID, const TDesC8& aVerProto, const HBufC& aSyncMLUserName, CNSmlURI* aSyncServer, const TDesC& aDMServerId, MSyncMLProgressObserver* aDMObserver )

    {

    if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))

    {

	CNSmlCmdsBase::ConstructL( aAgent, aSessionID, aVerProto,KNSmlSyncMLPublicId12 , aSyncMLUserName, aSyncServer, EFalse );

    }

    else

    {

    CNSmlCmdsBase::ConstructL( aAgent, aSessionID, aVerProto,KNSmlSyncMLPublicId , aSyncMLUserName, aSyncServer, EFalse );	

    }

	iDMServerId = aDMServerId.AllocL();

	iDMObserver = aDMObserver;

#ifdef __TEST_TREEMODULE

	iDMModule = CNSmlDmTestModule::NewL( this );

#else

	iDMModule = CNSmlDmModule::NewL( this );

#endif

	HBufC8* serverId = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aDMServerId);

	CleanupStack::PushL(serverId);

	iDMModule->SetServerL( *serverId );

	CleanupStack::PopAndDestroy(); //serverId

	// FOTA

	// init feature manager

	FeatureManager::InitializeLibL();

	if ( FeatureManager::FeatureSupported ( KFeatureIdSyncMlDmFota ) )

		{

		TRAPD ( error, iRepository = CRepository::NewL ( KCRUidDeviceManagementInternalKeys ) );

		if ( error != KErrNone )

			{

			iRepository = NULL;

			}

		}

	// FOTA end	

    }

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

// CNSmlDMCmds::DoDevInfoItemsL()

// Function which is called recursive when writing DevInfo items

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

void CNSmlDMCmds::DoDevInfoItemsL( const TDesC8& aURI ) 

	{

	iDMModule->FetchObjectL( aURI, KNullDesC8, 0, 0, ETrue );

	if ( !iDMDevInfo->iResults )

		{

		return;

		}

	iDMDevInfo->iResults = EFalse;

	if ( *iDMDevInfo->iFormat == _L8("node") )

		{

		HBufC8* childList = iDMDevInfo->iObject->AllocLC();

		TPtrC8 childListPtr( *childList );

		TInt pos = 0;

		TBool moreData = ETrue;

		do 

			{

			pos = childListPtr.Locate('/');

			if ( pos == KErrNotFound )

				{

				moreData = EFalse;

				pos = childListPtr.Length();

				}

			User::LeaveIfError( pos );

			HBufC8* childURI = HBufC8::NewLC( aURI.Length() + 1 + pos );

			*childURI = aURI;

			TPtr8 childURIPtr = childURI->Des();

			childURIPtr += _L8("/");

			HBufC8* segment = HBufC8::NewLC( pos );

			segment->Des().Copy( childListPtr.Left( pos ) );

			childURIPtr += *segment;

			DoDevInfoItemsL( *childURI );

			if ( moreData )

				{

				childListPtr.Set( childListPtr.Right( childListPtr.Length() - ( segment->Length() +1 ) ));

				}

			CleanupStack::PopAndDestroy( 2 ); // segment, childURI

			} while ( moreData );

		CleanupStack::PopAndDestroy(); // childList

		}

	else

		{

		if ( iDMDevInfo->iFirst )

			{

			iDMDevInfo->iFirst = EFalse;

			}

		else

			{

			(*iDMDevInfo->iItemListPtr)->next = new( ELeave ) SmlItemList_t;

			iDMDevInfo->iItemListPtr = &(*iDMDevInfo->iItemListPtr)->next;

			(*iDMDevInfo->iItemListPtr)->item = new( ELeave ) SmlItem_t;

			}

		DoSourceL( (*iDMDevInfo->iItemListPtr)->item->source, aURI );

		SmlMetInfMetInf_t* metInf;

		DoMetInfLC( metInf ); 

		PcdataNewL( metInf->format, *iDMDevInfo->iFormat );

		PcdataNewL( metInf->type, _L8("text/plain") );

		DoMetaL( (*iDMDevInfo->iItemListPtr)->item->meta, metInf );

		CleanupStack::Pop(); //metInf , only Pop because ownership has been changed

		PcdataNewL( (*iDMDevInfo->iItemListPtr)->item->data, *iDMDevInfo->iObject );

		}

	}

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

// CNSmlDMCmds::FreeDMDevinfo()

// 

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

void CNSmlDMCmds::FreeDMDevinfo()

	{

	if ( iDMDevInfo )

		{

		delete iDMDevInfo->iFormat;

		delete iDMDevInfo->iType; 

		delete iDMDevInfo->iObject;

		delete iDMDevInfo;

		iDMDevInfo = NULL;

		}

	}

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

// CNSmlDMCmds::AlertParameter()

// 

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

TInt CNSmlDMCmds::AlertParameter( const SmlPcdata_t* aData, const TDesC8& aParamID ) const

	{

	TInt valueNum = 0;

	if ( aData )

		{

		if ( aData->content )

			{

			TPtr8 parameters( (TUint8*) aData->content, aData->length, aData->length );

			TrimRightSpaceAndNull( parameters );

			TInt startPos = parameters.Find( aParamID );

			if ( startPos >= 0 )

				{

				if ( parameters.Length() > startPos + aParamID.Length() )

					{

					TPtrC8 strPart = parameters.Right( parameters.Length() - ( startPos + aParamID.Length() ) );

					TInt length = 0;

					while ( length < strPart.Length() )

						{

						TChar character = strPart[length];

						if ( character.IsDigit() )

							{

							++length;

							}

						else

							{

							break;

							}

						}

					TPtrC8 valueStr = strPart.Left(	length );

					TLex8 lexicalValue( valueStr );

					if ( lexicalValue.Val( valueNum ) != KErrNone )

						{

						valueNum = 0;

						}

					}

				}

			}

		}

	return valueNum; 

	}

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

// CNSmlDMCmds::AlertDataLC()

// 

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

HBufC8* CNSmlDMCmds::AlertDataLC( const SmlItemList_t* aItemList ) const

	{

	HBufC8* unicodeData = NULL;

	_DBG_FILE("CNSmlDMCmds::AlertDataLC: Begin");

	if (  aItemList )

		{

		if (  aItemList->next )

			{

			if (  aItemList->next->item )

				{

			  if (  aItemList->next->item->data )

				  {

				  if (  aItemList->next->item->data->content )

					{

					TPtr8 data( (TUint8*)  aItemList->next->item->data->content,  aItemList->next->item->data->length, aItemList->next->item->data->length );

					TrimRightSpaceAndNull( data );

					unicodeData = data.AllocLC();

					data.Zero();

					}

				  }

				}

			}

		}

	if ( unicodeData == NULL )

		{

		unicodeData = HBufC8::NewLC( 0 );

		}

	_DBG_FILE("CNSmlDMCmds::AlertDataLC: end");	

	return unicodeData;

	}

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

// CNSmlDMCmds::InitStatusToAtomicOrSequenceL()

// 

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

TInt CNSmlDMCmds::InitStatusToAtomicOrSequenceL( const TDesC8& aCmd, const SmlAtomic_t* aAtomic ) const

	{

	TInt statusID( 0 );

	statusID = iStatusToServer->CreateNewStatusElementL(); 

	iStatusToServer->SetCmdRefL( statusID, aAtomic->cmdID );

	iStatusToServer->SetCmdL( statusID, aCmd ); 

	if ( iStatusToServerNoResponse || IsFlagSet( aAtomic->flags, SmlNoResp_f ) )

		{

		iStatusToServer->SetNoResponse( statusID, ETrue );

		}

	else

		{

		iStatusToServer->SetNoResponse( statusID, EFalse );

		}

	iStatusToServer->SetStatusCodeL( statusID, TNSmlError::ESmlStatusOK );

	return statusID;

	}

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

// CNSmlDMCmds::DoAlertL()

// Makes Alert element and calls parser to generate xml

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

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

	{

	//initialise Alert

	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 );

	TInt ret = iGenerator->smlAlertCmd( alert);

	if ( ret != KWBXMLGeneratorOk )

		{

		User::Leave( ret );

		}

	CleanupStack::PopAndDestroy(); //alert

	//save Status response information for response status controlling

	CreateAndInitResponseItemL( KNSmlAgentAlert );

	}

// FOTA

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

// CNSmlDMCmds::DoGenericAlertL()

//	Makes a generic alert element (or possible many of them) 

//	and calls WBXML generator.

//	@param aFwMgmtUri. The uri which has been used in the exe command whose final result is 

//	about to be reported.

//	@param aMetaType. Meta/Type that should be used in the alert.

//	@param aMetaFormat. Meta/Format that should be used in the alert.

//	@param aFinalResult. The final result value which is reported to remote server.

//	@param aCorrelator. Correlator value used in the original exec command.

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

//

void CNSmlDMCmds::DoGenericAlertL ( const TDesC8& aFwMgmtUri, const TDesC8& aMetaType, const TDesC8& aMetaFormat, 

									TInt aFinalResult, const TDesC8& aFwCorrelator ) 

	{	

	SmlAlert_t* alert = new (ELeave) SmlAlert_t; 

	CleanupStack::PushL ( alert );

	alert->elementType = SML_PE_ALERT;

	DoCmdIdL ( alert->cmdID );

	PcdataNewL ( alert->data, KNSmlDMAgentGenericAlert );

	if ( aFwCorrelator != KNullDesC8 )

		{

		PcdataNewL ( alert->correlator, aFwCorrelator );		

		}

	alert->itemList = new ( ELeave ) SmlItemList_t;

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

	// URI comes without ./ from the adapter - add it now

	TPtr8 uri = HBufC8::NewLC ( aFwMgmtUri.Length() + KNSmlAgentRelativeURIPrefix().Length() )->Des();

	uri.Append ( KNSmlAgentRelativeURIPrefix );

	uri.Append ( aFwMgmtUri );

	DoSourceL ( alert->itemList->item->source, uri );

	CleanupStack::PopAndDestroy();  // uri

	SmlMetInfMetInf_t* metInf;

	DoMetInfLC ( metInf ); 

	PcdataNewL ( metInf->type, aMetaType );

	PcdataNewL ( metInf->format, aMetaFormat );

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

	CleanupStack::Pop(); // metInf

	TBuf8<KNSmlMaxInt32Length> result;

	result.Num ( aFinalResult );

	PcdataNewL ( alert->itemList->item->data, result );

	TInt ret = iGenerator->smlAlertCmd ( alert );

	if ( ret != KWBXMLGeneratorOk )

		{

		User::Leave( ret );

		}

	CleanupStack::PopAndDestroy(); //alert

	//response item is not created, because client is not

	//interested what server responds to generic alert.

	// ...

	}

//	@param aMetaType. Meta/Type that should be used in the alert.

//	@param aMetaFormat. Meta/Format that should be used in the alert.

//	@param aFinalResult. The final result value which is reported to remote server.

//	@param aCorrelator. Correlator value used in the original exec command.

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

//

void CNSmlDMCmds::DoGenericAlertL ( const TDesC8& aCorrelator, const RArray<CNSmlDMAlertItem>& aItemList ) 

	{	

	SmlAlert_t* alert = new (ELeave) SmlAlert_t; 

	CleanupStack::PushL ( alert );

	alert->elementType = SML_PE_ALERT;

	DoCmdIdL ( alert->cmdID );

	PcdataNewL ( alert->data, KNSmlDMAgentGenericAlert );

	if ( aCorrelator != KNullDesC8 )

		{

		PcdataNewL ( alert->correlator, aCorrelator );		

		}

	SmlItemList_t* itemPtr = NULL;

	TInt count = 1;

	if(&aItemList)

	    count = aItemList.Count();

	for(TInt i = 0; i<count; i++)

	{

	if( itemPtr == NULL)

	{

		alert->itemList = new ( ELeave ) SmlItemList_t;

		itemPtr = alert->itemList;		

	}

	else

	{

		itemPtr->next = new ( ELeave ) SmlItemList_t;

		itemPtr = itemPtr->next;

	}

	itemPtr->item = new ( ELeave ) SmlItem_t;

	// URI comes without ./ from the adapter - add it now

	TPtr8 uri = HBufC8::NewLC ((*aItemList[i].iSource).Length() + KNSmlAgentRelativeURIPrefix().Length())->Des();

	uri.Append ( KNSmlAgentRelativeURIPrefix );

	uri.Append ( *aItemList[i].iSource );

	DoSourceL ( itemPtr->item->source, uri );

	CleanupStack::PopAndDestroy();  // uri

	TPtr8 targeturi = HBufC8::NewLC ( (*aItemList[i].iTarget).Length())->Des();

	targeturi.Append ( *aItemList[i].iTarget);	

	DoTargetL ( itemPtr->item->target, targeturi  );

	CleanupStack::PopAndDestroy();  // targeturi   

	SmlMetInfMetInf_t* metInf;

	DoMetInfLC ( metInf ); 

	PcdataNewL ( metInf->type, *aItemList[i].iMetaType );

	PcdataNewL ( metInf->format, *aItemList[i].iMetaFormat );

	PcdataNewL ( metInf->mark, *aItemList[i].iMetaMark );

	DoMetaL ( itemPtr->item->meta, metInf );

	CleanupStack::Pop(); // metInf

	PcdataNewL ( itemPtr->item->data, *aItemList[i].iData );