/*

* Copyright (c) 2002 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: 

*     Parser for the WirelessVillage OTA settings.

*     Supports only wbxml.

*

*/

#include <e32std.h>

#include <xmlelemt.h>

#include <cnode.h>

#include "wvsettings.h"

#include "wvsettingsdef.h"

// CONSTANTS

const TInt KMaxStringSize	= 200;

const TInt KElemAndEndTokenLength	= 2;

const TInt KEndTokenLength	= 1;

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

// CWVSettingsParser::CWVSettingsParser()

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

//

CWVSettingsParser::CWVSettingsParser():

iListEmpty(ETrue),

iOTAVersion(EFalse),

iPassword(EFalse),

iPreferredProtocol(EFalse),

iProxyAddress(EFalse),

iProxyPort(EFalse),

iProxyUser(EFalse),

iProxyPassword(EFalse),

iRefName(EFalse),

iSAP4WaySupportedSms(EFalse),

iSAP4WaySupportedHttp(EFalse),

iSAPMobileNumber(EFalse),

iSAPURI(EFalse),

iSettingsName(EFalse),

iSMSCMobileNumber(EFalse),

iUserID(EFalse),

iSupportedVersions(EFalse),

iCommon(EFalse),

iSms(EFalse),

iHttp(EFalse),

iProxy(EFalse)

	{

	iDatabufferSize = 0;

	iParsedBytes = 0;

	}

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

// CWVSettingsParser::NewL()

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

//

EXPORT_C CWVSettingsParser* CWVSettingsParser::NewL()

	{

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

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop();

    return self;  

	}

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

// CWVSettingsParser::ConstructL()

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

//

void CWVSettingsParser::ConstructL()

	{

	iWVSupportedVersions = new (ELeave) CArrayPtrFlat<HBufC>(1);

	iRootElement = CXmlElement::NewL (&KWVSettings, NULL);

	iWVOTAVersion = HBufC::NewL(KMaxStringSize);

	iWVPassword = HBufC::NewL (KMaxStringSize);

	iWVPreferredProtocol = HBufC::NewL (KMaxStringSize);

	iWVProxyAddress = HBufC::NewL (KMaxStringSize);

	iWVProxyPort = HBufC::NewL (KMaxStringSize);

	iWVProxyUser = HBufC::NewL (KMaxStringSize);

	iWVRefName = HBufC::NewL (KMaxStringSize);

	iWVSAPFourWaySupported1 = HBufC::NewL (KMaxStringSize);

	iWVSAPFourWaySupported2 = HBufC::NewL (KMaxStringSize);

	iWVSAPMobileNumber = HBufC::NewL (KMaxStringSize);

	iWVSAPURI = HBufC::NewL (KMaxStringSize);

	iWVSettingsName = HBufC::NewL (KMaxStringSize);

	iWVSMSCMobileNumber = HBufC::NewL (KMaxStringSize);

	iWVUserID = HBufC::NewL (KMaxStringSize);

	iWVProxyPassword = HBufC::NewL (KMaxStringSize);

	}

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

// CWVSettingsParser::~CWVSettingsParser()

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

//

CWVSettingsParser::~CWVSettingsParser()

	{

	delete iRootElement;

	delete iWVSettingsName;

	delete iWVOTAVersion;

	delete iWVPassword;

	delete iWVPreferredProtocol;

	delete iWVProxyAddress; 

	delete iWVProxyPort;

	delete iWVProxyUser;

	delete iWVRefName;

	delete iWVSAPFourWaySupported1;

	delete iWVSAPFourWaySupported2;

	delete iWVSAPMobileNumber;

	delete iWVSAPURI;

	delete iWVSMSCMobileNumber;

	if (iWVSupportedVersions != NULL)

		{

		iWVSupportedVersions->ResetAndDestroy ();

		delete iWVSupportedVersions;

		}

	delete iWVUserID;	

	delete iWVProxyPassword;

	}

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

// CWVSettingsParser::ParseL

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

//

EXPORT_C TBool CWVSettingsParser::ParseL(TDesC8& aDataBuffer)

	{

	DoParseL (aDataBuffer);

	CreateXmlElementTreeL ();

	TBool errNotFound = Validate ();

	return errNotFound;

	}

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

// CWVSettingsParser::CreateXmlElementTreeL

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

//

void CWVSettingsParser::CreateXmlElementTreeL ()

	{

	/* used for the CleanupStack */

	TInt nbrOfElements = 0;

	/* Create all elements and set the data */

	if (iOTAVersion)

		{

		CXmlElement* WVOTAVersion = CXmlElement::NewL (&KWVOTAVersion, iRootElement);

		CleanupStack::PushL(WVOTAVersion);

		WVOTAVersion->SetTextL(*iWVOTAVersion);

		iRootElement->AppendChildL (WVOTAVersion);

		nbrOfElements++;

		}

	if (iCommon)

		{

		CXmlElement* WVCommon = CXmlElement::NewL (&KWVCommon, iRootElement);

		CleanupStack::PushL(WVCommon);

		if (iSettingsName)

			{

			CXmlElement* WVSettingsName = CXmlElement::NewL (&KWVSettingsName, WVCommon);

			CleanupStack::PushL(WVSettingsName);

			WVSettingsName->SetTextL(*iWVSettingsName);

			WVCommon->AppendChildL (WVSettingsName);

			nbrOfElements++;

			}

		if (iRefName)

			{

			CXmlElement* WVRefName = CXmlElement::NewL (&KWVRefName, WVCommon);

			CleanupStack::PushL(WVRefName);

			WVRefName->SetTextL(*iWVRefName);

			WVCommon->AppendChildL (WVRefName);

			nbrOfElements++;

			}

		if (iSupportedVersions)

			{

			CXmlElement* WVSupportedVersion;

			TInt nbrOfVersions = iWVSupportedVersions->Count();

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

				{

				WVSupportedVersion = CXmlElement::NewL (&KWVSupportedVersion, WVCommon);

				CleanupStack::PushL(WVSupportedVersion);

				WVSupportedVersion->SetTextL(*iWVSupportedVersions->At(i));

				WVCommon->AppendChildL (WVSupportedVersion);

				nbrOfElements++;

				}

			}

		if (iUserID)

			{

			CXmlElement* WVUserID = CXmlElement::NewL (&KWVUserID, WVCommon);

			CleanupStack::PushL(WVUserID);

			WVUserID->SetTextL(*iWVUserID);

			WVCommon->AppendChildL (WVUserID);

			nbrOfElements++;

			}

		if (iPassword)

			{

			CXmlElement* WVPassword = CXmlElement::NewL (&KWVPassword, WVCommon);

			CleanupStack::PushL(WVPassword);

			WVPassword->SetTextL(*iWVPassword);

			WVCommon->AppendChildL (WVPassword);

			nbrOfElements++;

			}

		if (iPreferredProtocol)

			{

			CXmlElement* WVPreferredProtocol = CXmlElement::NewL (&KWVPreferredProtocol, WVCommon);

			CleanupStack::PushL(WVPreferredProtocol);

			WVPreferredProtocol->SetTextL(*iWVPreferredProtocol);

			WVCommon->AppendChildL (WVPreferredProtocol);

			nbrOfElements++;

			}

		iRootElement->AppendChildL (WVCommon);

		nbrOfElements++;

		} //WVCommon

	if (iSms)

		{

		CXmlElement* WVSMS = CXmlElement::NewL (&KWVSMS, iRootElement);

		CleanupStack::PushL(WVSMS);

		if (iSAPMobileNumber)

			{

			CXmlElement* WVSAPMobileNumber = CXmlElement::NewL (&KWVSAPMobileNumber, WVSMS);

			CleanupStack::PushL(WVSAPMobileNumber);

			WVSAPMobileNumber->SetTextL(*iWVSAPMobileNumber);

			WVSMS->AppendChildL (WVSAPMobileNumber);

			nbrOfElements++;

		}

		if (iSAP4WaySupportedSms)

			{

			CXmlElement* WVSAPFourWaySupported1 = CXmlElement::NewL (&KWVSAPFourWaySupported, WVSMS);

			CleanupStack::PushL(WVSAPFourWaySupported1);

			WVSAPFourWaySupported1->SetTextL(*iWVSAPFourWaySupported1);

			WVSMS->AppendChildL (WVSAPFourWaySupported1);

			nbrOfElements++;

			}

		if (iSMSCMobileNumber)

			{

			CXmlElement* WVSMSCMobileNumber = CXmlElement::NewL (&KWVSMSCMobileNumber, WVSMS);

			CleanupStack::PushL(WVSMSCMobileNumber);

			WVSMSCMobileNumber->SetTextL(*iWVSMSCMobileNumber);

			WVSMS->AppendChildL (WVSMSCMobileNumber);

			nbrOfElements++;

			}

		iRootElement->AppendChildL (WVSMS);

		nbrOfElements++;

		} // WVSMS

	if (iHttp)

		{

		CXmlElement* WVHTTP = CXmlElement::NewL (&KWVHTTP, iRootElement);

		CleanupStack::PushL(WVHTTP);

		if ( iSAPURI)

			{

			CXmlElement* WVSAPURI = CXmlElement::NewL (&KWVSAPURI, WVHTTP);

			CleanupStack::PushL(WVSAPURI);

			WVSAPURI->SetTextL(*iWVSAPURI);

			WVHTTP->AppendChildL (WVSAPURI);

			nbrOfElements++;

			}

		if (iSAP4WaySupportedHttp)

			{

			CXmlElement* WVSAPFourWaySupported2 = CXmlElement::NewL (&KWVSAPFourWaySupported, WVHTTP);

			CleanupStack::PushL(WVSAPFourWaySupported2);

			WVSAPFourWaySupported2->SetTextL(*iWVSAPFourWaySupported2);

			WVHTTP->AppendChildL (WVSAPFourWaySupported2);

			nbrOfElements++;

			}

		if (iProxy)

			{

			CXmlElement* WVProxy = CXmlElement::NewL (&KWVProxy, WVHTTP);

			CleanupStack::PushL(WVProxy);

			if ( iProxyAddress)

				{

				CXmlElement* WVProxyAddress = CXmlElement::NewL (&KWVProxyAddress, WVProxy);

				CleanupStack::PushL(WVProxyAddress);

				WVProxyAddress->SetTextL(*iWVProxyAddress);

				WVProxy->AppendChildL (WVProxyAddress);

				nbrOfElements++;

				}

			if (iProxyPort)

				{

				CXmlElement* WVProxyPort = CXmlElement::NewL (&KWVProxyPort, WVProxy);

				CleanupStack::PushL(WVProxyPort);

				WVProxyPort->SetTextL(*iWVProxyPort);

				WVProxy->AppendChildL (WVProxyPort);

				nbrOfElements++;

				}

			if (iProxyUser)

				{

				CXmlElement* WVProxyUser = CXmlElement::NewL (&KWVProxyUser, WVProxy);

				CleanupStack::PushL(WVProxyUser);

				WVProxyUser->SetTextL(*iWVProxyUser);

				WVProxy->AppendChildL (WVProxyUser);

				nbrOfElements++;

				}

			if (iProxyPassword)

				{

				CXmlElement* WVProxyPassword = CXmlElement::NewL (&KWVProxyPassword, WVProxy);

				CleanupStack::PushL(WVProxyPassword);

				WVProxyPassword->SetTextL(*iWVProxyPassword);

				WVProxy->AppendChildL (WVProxyPassword);

				nbrOfElements++;

				}

			WVHTTP->AppendChildL (WVProxy);

			nbrOfElements++;

			} // WVProxy

		iRootElement->AppendChildL (WVHTTP);

		nbrOfElements++;

		} // WVHTTP

	//for testing

	//iRootElement->WriteIntoFileL();

	CleanupStack::Pop(nbrOfElements);  // elements

	}

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

// CWVSettingsParser::Root ()

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

//

EXPORT_C CXmlElement* CWVSettingsParser::Root ()

	{

	return iRootElement;

	}

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

// CWVSettingsParser::DoParseL

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

//

void CWVSettingsParser::DoParseL(TDesC8& aDataBuffer)

	{

	TBool done = EFalse;

	TUint8* dataPtr = (TUint8*) aDataBuffer.Ptr();

	iDatabufferSize = aDataBuffer.Size();

	if (iDatabufferSize > 0)

		{

		// save the buffer's start point

		TUint8* startPtr = dataPtr;

		//version, public id, charset

		dataPtr = dataPtr+3;

		//string table 

		dataPtr++;

		// this is used for 4waySupported

		TBool sms = EFalse;

		while(!done)

		{

			switch (*dataPtr)

			{

			case (KWV_TAG_CONTENT + K_WVSETTINGS):

				dataPtr++;

				break;

			case (KWV_TAG_CONTENT + K_WVOTAVERSION):	

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVOTAVersion);

				iOTAVersion = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVCOMMON):

				dataPtr++;

				iCommon = ETrue;

			break;

			case(KWV_TAG_CONTENT + K_WVSETTINGSNAME):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSettingsName);

				iSettingsName = ETrue;

			break;

			case(KWV_TAG_CONTENT + K_WVREFNAME):   

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVRefName);

				iRefName = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVSUPPORTEDVERSION):

				dataPtr = dataPtr + ReadSupportedVersionsL(dataPtr);

				iSupportedVersions = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVUSERID):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVUserID);

				iUserID = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVPASSWORD):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVPassword);

				iPassword = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVPREFERREDPROTOCOL):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVPreferredProtocol);

				iPreferredProtocol = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVSMS):

				dataPtr++;

				sms = ETrue;

				iSms = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVSAPMOBILENUMBER):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPMobileNumber);

				iSAPMobileNumber = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVSAPFOURWAYSUPPORTED):

				// NOTE This assumes that if msg has WVSMS element, it comes always before WVHTTP element

				// anyhow the specs say that...

				// ...The elements in the WV settings must be sent in a same order as the 

				// content models of these DTD elements define them

				if (sms)

					{

					dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPFourWaySupported1);

					sms = EFalse;

					iSAP4WaySupportedSms = ETrue;

					}

				else

					{

					dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPFourWaySupported2);

					iSAP4WaySupportedHttp = ETrue;

					}

			break;

			case (KWV_TAG_CONTENT + K_WVSMSMOBILENUMBER):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSMSCMobileNumber);

				iSMSCMobileNumber = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVHTTP):

				dataPtr++;

				iHttp = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVSAPURI):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPURI);

				iSAPURI = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVPROXY):

				dataPtr++;

				iProxy = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVPROXYADDRESS):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyAddress);

				iProxyAddress = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVPROXYPORT):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyPort);

				iProxyPort = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVPROXYUSER):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyUser);

				iProxyUser = ETrue;

			break;

			case (KWV_TAG_CONTENT + K_WVPROXYPASSWORD):

				dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyPassword);

				iProxyPassword = ETrue;

			break;

			case K_WVOTAVERSION:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVOTAVersion);

				iOTAVersion = ETrue;

			break;

			case K_WVCOMMON:

				dataPtr+=KElemAndEndTokenLength; 

				iCommon = ETrue;

			break;

			case K_WVSETTINGSNAME:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSettingsName);

				iSettingsName = ETrue;

			break;

			case K_WVREFNAME:   

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVRefName);

				iRefName = ETrue;

			break;

			case K_WVSUPPORTEDVERSION:

				dataPtr+=KElemAndEndTokenLength; 

				iSupportedVersions = ETrue;

			break;

			case K_WVUSERID:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVUserID);

				iUserID = ETrue;

			break;

			case K_WVPASSWORD:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVPassword);

				iPassword = ETrue;

			break;

			case K_WVPREFERREDPROTOCOL:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVPreferredProtocol);

				iPreferredProtocol = ETrue;

			break;

			case K_WVSMS:

				dataPtr+=KElemAndEndTokenLength; 

				iSms = ETrue;

			break;

			case K_WVSAPMOBILENUMBER:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPMobileNumber);

				iSAPMobileNumber = ETrue;

			break;

			case K_WVSAPFOURWAYSUPPORTED:  

				if (sms)

					{

					dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPFourWaySupported1);

					sms = EFalse;

					iSAP4WaySupportedSms = ETrue;

					}

				else

					{

					dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPFourWaySupported2);

					iSAP4WaySupportedHttp = ETrue;

					}

			break;

			case K_WVSMSMOBILENUMBER:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSMSCMobileNumber);

				iSMSCMobileNumber = ETrue;

			break;

			case K_WVHTTP:

				dataPtr+=KElemAndEndTokenLength; 

				iHttp = ETrue;

			break;

			case K_WVSAPURI:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPURI);

				iSAPURI = ETrue;

			break;

			case K_WVPROXY:

				dataPtr+=KElemAndEndTokenLength; 

				iProxy = ETrue;

			break;

			case K_WVPROXYADDRESS:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyAddress);

				iProxyAddress = ETrue;

			break;

			case K_WVPROXYPORT:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyPort);

				iProxyPort = ETrue;

			break;

			case K_WVPROXYUSER:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyUser);

				iProxyUser = ETrue;

			break;

			case K_WVPROXYPASSWORD:

				dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyPassword);

				iProxyPassword = ETrue;

			break;