/*

* 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:  for dbcaps streaming and converting to CSmlDataStoreFormat.

*

*/

#include <stringpool.h>

#include <s32strm.h>

#include <nsmlunicodeconverter.h>

#include "nsmldbcaps.h"

#include "smldevinfdtd.h"

#include "smlmetinfdtd.h"

#include "smldevinftags.h"

#include "NSmldbcapsSerializer.h"

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

// Constants

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

_LIT8( KNSmlFolderType, "application/vnd.omads-folder+xml" );

_LIT8( KNSmlFolderVersion, "1.2" );

const TInt KNSml32BitNumLength = 12;

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

// TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::NewLC()

// constructs CNSmlFilterCapabilityData

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

TNSmlDbCapsSerializer::CNSmlFilterCapabilityData* TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::NewLC()

	{

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

	CleanupDeletePushL( self );

	return self;

	}

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

// TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::~CNSmlFilterCapabilityData()

// C++ destructor

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

TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::~CNSmlFilterCapabilityData()

	{

	iFilterCapabilities.ResetAndDestroy();

	iMimeVersion.Close();

	iMimeType.Close();

	for (TInt i = 0; i < iKeywordList.Count(); i++ )

		{

		iKeywordList[i].Close();

		}

	iKeywordList.Reset();

	for (TInt i = 0; i < iPropertyList.Count(); i++)

		{

		iPropertyList[i].Close();

		}

	iPropertyList.Reset();

	}

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

// TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::MakeL()

// C++ destructor

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

void TNSmlDbCapsSerializer::CNSmlFilterCapabilityData::MakeL( 

	const RStringPool& aStringPool, const CArrayFix<TNSmlFilterCapData>& aFilterInfoArr )

	{

	if ( &aFilterInfoArr == NULL )

		{

		return;

		}

	for( TInt i = 0 ; i < aFilterInfoArr.Count(); i++ )

		{

		const TNSmlFilterCapData& fcd = aFilterInfoArr[i];

		switch( fcd.iTag )

			{

			case TNSmlFilterCapData::ECtType:

				iMimeType = aStringPool.OpenFStringL( fcd.iValue );

				break;

			case TNSmlFilterCapData::EVerCt:

				iMimeVersion = aStringPool.OpenFStringL( fcd.iValue );

				break;

			case TNSmlFilterCapData::EFilterKeyword:

				{

				RString tmprstr( aStringPool.OpenStringL( fcd.iValue ) );

				CleanupClosePushL( tmprstr );

				iKeywordList.AppendL( tmprstr );

				CleanupStack::Pop(); //tmprstr

				}

				break;

			case TNSmlFilterCapData::EPropName:

				{

				RString tmprstr( aStringPool.OpenStringL( fcd.iValue ) );

				CleanupClosePushL( tmprstr );

				iPropertyList.AppendL( tmprstr );

				CleanupStack::Pop(); //tmprstr

				}

				break;

			default:

				User::Leave( KErrArgument );

			}

		}

	CSmlFilterCapability* fc = CSmlFilterCapability::NewLC();

	fc->SetMimeTypeL( iMimeType );

	fc->SetMimeVersionL( iMimeVersion );

	fc->SetPropertiesListL( iPropertyList );

	fc->SetKeyWordListL( iKeywordList );

	iFilterCapabilities.AppendL( fc );

	CleanupStack::Pop( fc );

	}

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

// TNSmlDbCapsSerializer::CSmlDataFieldFromDbCaps::NewLC()

// constructs CSmlDataField from parameters

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

CSmlDataField* TNSmlDbCapsSerializer::CNSmlDataFieldFromDbCaps::NewLC(

														const RStringPool& aStringPool,

														const TPtrC8& aDisplayName, 

														const TPtrC8& aPropName,

														const TPtrC8& aDataType,

														const sml_pcdata_list_s* aValEnums )

	{

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

	CleanupStack::PushL( self );

	//display name

	NSmlUnicodeConverter::HBufC16InUnicodeLC( aDisplayName, self->iDisplayName );

	CleanupStack::Pop( self->iDisplayName ); // self->iDisplayName

	//name

	self->iName = aStringPool.OpenStringL( aPropName );

	//data type

	self->iDataType = aStringPool.OpenStringL( aDataType );

	//value enums

	for ( ; aValEnums; aValEnums = aValEnums->next )

		{

		const SmlPcdataPtr_t val = aValEnums->data;

		if ( val )

			{

			RString tmprstr( aStringPool.OpenStringL( TNSmlDbCapsSerializer::SafePtr( val ) ) );

			CleanupClosePushL( tmprstr );

			self->iEnumValues.AppendL( tmprstr );

			CleanupStack::Pop(); // tmprstr

			}

		}

	return self;

	}

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

// TNSmlDbCapsSerializer::CSmlDataPropertyParamFromDbCaps::NewLC()

// constructs CSmlDataPropertyParam from parameters

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

CSmlDataPropertyParam* TNSmlDbCapsSerializer::CNSmlDataPropertyParamFromDbCaps::NewLC(

														const RStringPool& aStringPool,

														const sml_devinf_propparam_s* aDipp )

	{

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

	CleanupStack::PushL( self );

	//diplay name, property name, datatype, value enums -> iField

	self->iField = CNSmlDataFieldFromDbCaps::NewLC( aStringPool, 

		TNSmlDbCapsSerializer::SafePtr( aDipp->displayname ), 

		TNSmlDbCapsSerializer::SafePtr( aDipp->paramname ),

		TNSmlDbCapsSerializer::SafePtr( aDipp->datatype ), 

		aDipp->valenum );

	CleanupStack::Pop( self->iField ); // self->iField

	return self;

	}

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

// TNSmlDbCapsSerializer::CSmlDataPropertyFromDbCaps::NewLC()

// constructs CSmlDataProperty from parameters

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

CSmlDataProperty* TNSmlDbCapsSerializer::CNSmlDataPropertyFromDbCaps::NewLC(

														const RStringPool& aStringPool,

														const sml_devinf_property_s* aDip )

	{

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

	CleanupStack::PushL( self );

	//max occur

	if( aDip->maxoccur )

		{

		TLex8 lex( aDip->maxoccur->Data() );

		User::LeaveIfError( lex.Val( self->iMaxOccur, EDecimal ) );

		self->iFlags |= KSmlDataProperty_HasMaxOccur;

		}

	//max size

	if ( aDip->maxsize )

		{

		TLex8 lex( aDip->maxsize->Data() );

		User::LeaveIfError( lex.Val( self->iMaxSize, EDecimal ) );

		self->iFlags |= KSmlDataProperty_HasMaxSize;

		}

	//options

	if ( aDip->notruncate )

		{

		self->iFlags |= KSmlDataProperty_NoTruncate;

		}

	//diplay name, property name, datatype, value enums -> iField

	self->iField = CNSmlDataFieldFromDbCaps::NewLC( aStringPool, 

		TNSmlDbCapsSerializer::SafePtr( aDip->displayname ), 

		TNSmlDbCapsSerializer::SafePtr( aDip->propname ),

		TNSmlDbCapsSerializer::SafePtr( aDip->datatype ), 

		aDip->valenum );

	CleanupStack::Pop( self->iField ); // self->iField

	SmlDevInfPropParamListPtr_t dippl = aDip->propparam;

	for ( ; dippl; dippl = dippl->next )

		{

		SmlDevInfPropParamPtr_t dipp = dippl->data;

		if ( dipp )

			{

			CSmlDataPropertyParam* temppoint = CNSmlDataPropertyParamFromDbCaps::NewLC( aStringPool, dipp );

			self->iParams.AppendL( temppoint );

			CleanupStack::Pop(); // temppoint

			}

		}

	return self;

	}

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

// TNSmlDbCapsSerializer::CSmlFilterCapabilityFromDbCaps::NewLC()

// constructs CSmlFilterCapability from parameters

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

CSmlFilterCapability* TNSmlDbCapsSerializer::CNSmlFilterCapabilityFromDbCaps::NewLC( 

														const RStringPool& aStringPool, 

														const sml_devinf_filtercap_s* aFtCap )

	{

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

	CleanupStack::PushL( self );

	//mime type

	self->iMimeType = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aFtCap->cttype ) );

	//mime version

	self->iMimeVersion = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aFtCap->verct ) );

	//keywords

	SmlPcdataListPtr_t keys = aFtCap->filterkeyword;

	for( ; keys; keys = keys->next )

		{

		if ( keys->data )

			{

			const TDesC8& key = keys->data->Data();

			RString rkey( aStringPool.OpenStringL( key ) );

			CleanupClosePushL( rkey );

			self->iKeywordList.AppendL( rkey );

			CleanupStack::Pop(); // rkey

			}

		}

	//properties

	SmlPcdataListPtr_t props = aFtCap->propname;

	for( ; props; props = props->next )

		{

		if ( props->data )

			{

			const TDesC8& prop = props->data->Data();

			RString rprop( aStringPool.OpenStringL( prop ) );

			CleanupClosePushL( rprop );

			self->iPropertyList.AppendL( rprop );

			CleanupStack::Pop(); // rkey

			}

		}

	return self;

	}

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

// TNSmlDbCapsSerializer::CSmlMimeFormatFromDbCaps::NewLC()

// constructs CSmlMimeFormat from parameters

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

CSmlMimeFormat* TNSmlDbCapsSerializer::CNSmlMimeFormatFromDbCaps::NewLC( 

														const RStringPool& aStringPool, 

														const sml_devinf_ctcap_s& aDic )

	{

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

	CleanupStack::PushL( self );

	//mime type

	self->iMimeType = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aDic.cttype ) );

	//mime version

	self->iMimeVersion = aStringPool.OpenFStringL( TNSmlDbCapsSerializer::SafePtr( aDic.verct ) );

	//field level

	self->iFieldLevel = EFalse;

	if ( aDic.fieldlevel )

		{

		self->iFieldLevel = ETrue;

		}

	//properties

	SmlDevInfPropertyListPtr_t dipl = aDic.property;

	for ( ; dipl; dipl = dipl->next )

		{

		const SmlDevInfPropertyPtr_t dip = dipl->data;

		if ( dip )

			{

			CSmlDataProperty *temppoint = CNSmlDataPropertyFromDbCaps::NewLC( aStringPool, dip );

			self->iProperties.AppendL( temppoint );

			CleanupStack::Pop(); // temppoint

			}

		}

	return self;

	}

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

// TNSmlDbCapsSerializer::CSmlDataStoreFormatFromDbCaps::NewLC()

// constructs CSmlDataStoreFormat from parameters

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

CSmlDataStoreFormat* TNSmlDbCapsSerializer::CNSmlDataStoreFormatFromDbCaps::NewLC(

														const RStringPool& aStringPool,

														const CNSmlDbCaps& aDbCaps )

	{

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

	CleanupStack::PushL( self );

	const sml_devinf_datastore_s* dds = aDbCaps.Datastore();

	//display name

	//sync types

	TSmlSyncTypeMask& synctype( self->iSyncTypeMask );

	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ETwoWaySync ) )

		{

		synctype.SetSupported( ESmlTwoWay );

		}

	else

		{

		synctype.SetNotSupported( ESmlTwoWay );

		}

	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::EOneWaySyncFromServer ) )

		{

		synctype.SetSupported( ESmlOneWayFromServer );

		}

	else

		{

		synctype.SetNotSupported( ESmlOneWayFromServer );

		}

	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::EOneWaySyncFromClient ) )

		{

		synctype.SetSupported( ESmlOneWayFromClient );

		}

	else

		{

		synctype.SetNotSupported( ESmlOneWayFromClient );

		}

	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ESlowTwoWaySync ) ) 

		{

		synctype.SetSupported( ESmlSlowSync );

		}

	else

		{

		synctype.SetNotSupported( ESmlSlowSync );

		}

	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ERefreshSyncFromServer ) )

		{

		synctype.SetSupported( ESmlRefreshFromServer );	

		}

	else

		{

		synctype.SetNotSupported( ESmlRefreshFromServer );

		}

	if ( aDbCaps.SupportsSyncType( CNSmlDbCaps::ERefreshSyncFromClient ) ) 

		{

		synctype.SetSupported( ESmlRefreshFromClient );

		}

	else

		{

		synctype.SetNotSupported( ESmlRefreshFromClient );

		}

	if ( dds->dsmem )

		{

		//max size

		if ( dds->dsmem->maxmem )

			{

			TLex8 lex( dds->dsmem->maxmem->Data() );

			User::LeaveIfError( lex.Val( self->iMaxSize, EDecimal ) );

			self->iFlags |= KSmlDataStore_HasMaxSize;

			}

		//max items

		if ( dds->dsmem->maxid )

			{

			TLex8 lex( dds->dsmem->maxid->Data() );

			User::LeaveIfError( lex.Val( self->iMaxItems, EDecimal ) );

			self->iFlags |= KSmlDataStore_HasMaxItems;

			}

		}

	//options

	if ( dds->supportHierarchicalSync )

		{

		self->iFlags |= KSmlDataStore_Hierarchical;

		}

	//filter caps

	const sml_devinf_filtercaplist_s* filterList = aDbCaps.FilterCapsList();

	for ( ; filterList; filterList = filterList->next )

		{

		const SmlDevInfFilterCapPtr_t ft = filterList->data;

		if (ft)

			{

			CSmlFilterCapability* fc = CNSmlFilterCapabilityFromDbCaps::NewLC( aStringPool, ft );

			self->iFilterCapabilities.AppendL( fc );

			CleanupStack::Pop(); // fc

			}

		}

	// CSmlMimeFormat

	RPointerArray<CSmlMimeFormat> mimeFormatArray;

	CleanupClosePushL( mimeFormatArray );

	// First search all mime types that server supports at receiving

	// RX-pref

	CSmlMimeFormat* tempFormatRX = CSmlMimeFormat::NewLC();

	const TPtrC8& ctTypeRX = TNSmlDbCapsSerializer::SafePtr( dds->rxpref->cttype );

	const TPtrC8& verCtRX = TNSmlDbCapsSerializer::SafePtr( dds->rxpref->verct );

	if ( ctTypeRX.Compare( KNullDesC8 ) != 0 && verCtRX.Compare( KNullDesC8 ) != 0 )

		{

		RStringF mimeFormatRX = aStringPool.OpenFStringL( ctTypeRX );

		RStringF mimeVersionRX = aStringPool.OpenFStringL( verCtRX );

		tempFormatRX->SetMimeTypeL( mimeFormatRX );

		tempFormatRX->SetMimeVersionL( mimeVersionRX );

		mimeFormatArray.AppendL( tempFormatRX );

		CleanupStack::Pop(); // tempFormatRX

		}

	else

		{

		CleanupStack::PopAndDestroy(); // tempFormatRX

		}

	// RXs

	if ( dds )

		{

		SmlDevInfXmitListPtr_t rx = dds->rx;

		for ( ; rx ; rx = rx->next )

			{

			CSmlMimeFormat* tempFormat = CSmlMimeFormat::NewLC();

			const TPtrC8& ctType = TNSmlDbCapsSerializer::SafePtr( rx->data->cttype );

			const TPtrC8& verCt = TNSmlDbCapsSerializer::SafePtr( rx->data->verct );

			if ( ctType.Compare( KNullDesC8 ) != 0 && verCt.Compare( KNullDesC8 ) != 0 )

				{

				RStringF mimeFormat = aStringPool.OpenFStringL( ctType );

				RStringF mimeVersion = aStringPool.OpenFStringL( verCt );

				tempFormat->SetMimeTypeL( mimeFormat );

				tempFormat->SetMimeVersionL( mimeVersion );

				mimeFormatArray.AppendL( tempFormat );

				CleanupStack::Pop(); // tempFormat

				}

			else

				{

				CleanupStack::PopAndDestroy(); // tempFormat

				}

			}

		}

	const sml_devinf_ctcaplist_s*  ctCapList = dds->ctcap;

	if ( ctCapList == 0 )

		{

		ctCapList = aDbCaps.CtCaps();

		}

	// Then add CTCaps to correct mime types

	if ( ctCapList != 0 )

	    {    

        for (; ctCapList; ctCapList = ctCapList->next )

    		{

    		const SmlDevInfCtCapPtr_t ctCap = ctCapList->data;

    		if ( ctCap->cttype->Data() == KNSmlFolderType )

    			{

    			SmlDevInfPropertyListPtr_t dipl = ctCap->property;

    			for ( ; dipl; dipl = dipl->next )

    				{

    				const SmlDevInfPropertyPtr_t dip = dipl->data;

    				if ( dip )

    					{

    					CSmlDataProperty *temppoint = CNSmlDataPropertyFromDbCaps::NewLC( aStringPool, dip );

    					self->iFolderProperties.AppendL( temppoint );

    					CleanupStack::Pop(); //  temppoint

    					}

    				}

    			}

    		else

    			{

    			for ( TInt j(0); j < mimeFormatArray.Count(); j++ )

    			    {

    			    if ( mimeFormatArray[j]->MimeType().DesC().Compare( ctCap->cttype->Data() ) == 0 )

    			        {

    			        // Mime version is only in rx-pref or in rx so it must be copied to new mime format