/*

* 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:  Client's Status command buffering

*

*/

//#include "nsmlcliagdefines.h"

#include "NSmlStatusContainer.h"

#include "nsmlcliagconstants.h"

#include "nsmlerror.h"

#include "smlmetinfdtd.h"

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

// CNSmlStatusContainer::CNSmlStatusContainer

// Constructor, nothing special in here.

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

//

CNSmlStatusContainer::CNSmlStatusContainer()

	{

	}

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

// CNSmlStatusContainer::ConstructL()

// Two-way construction. Constructor may leave in EPOC.

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

//

void CNSmlStatusContainer::ConstructL(TBool aClearText)

	{

	iClearText = aClearText;

	iStatusArray = new( ELeave ) CArrayFixFlat<TStatusData>(KNSmlStatusArrayGranularity);

	iArrayInd = -1;

	}

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

// CNSmlStatusContainer::~CNSmlStatusContainer()

// Destructor

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

//

CNSmlStatusContainer::~CNSmlStatusContainer()

	{

	delete iMsgRef;

	if ( !iStatusArray )

		{

		return;

		}

	TInt arrayCount = iStatusArray->Count();

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

		{

		FreeResources( i );

		}

	delete iStatusArray; 

	}

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

// CNSmlStatusContainer::NewL()

// Creates new instance of CNSmlStatusContainer. 

// Does not leave instance pointer to CleanupStack.

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

//

CNSmlStatusContainer* CNSmlStatusContainer::NewL( TBool aClearText)

	{

	CNSmlStatusContainer* self = CNSmlStatusContainer::NewLC(aClearText);

	CleanupStack::Pop();

	return( self );

	}

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

// CNSmlStatusContainer::NewLC()

// Creates new instance of CNSmlStatusContainer 

// Leaves instance pointer to CleanupStack.

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

//

CNSmlStatusContainer* CNSmlStatusContainer::NewLC(TBool aClearText)

	{

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

	CleanupStack::PushL( self );

	self->ConstructL(aClearText);

	return( self );

	}

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

// CNSmlStatusContainer::InitMsgRefL

// Creates new empty Status element and adds it to the array

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

//

void CNSmlStatusContainer::InitMsgRefL( const SmlPcdata_t* aMsgRef )

	{

	delete iMsgRef;

	iMsgRef = NULL;

	CopyPcdataL( aMsgRef, iMsgRef );

	}

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

// CNSmlStatusContainer::CreateNewStatusElementL()

// Creates new empty Status element and adds it to the array

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

//

EXPORT_C TInt CNSmlStatusContainer::CreateNewStatusElementL()

	{

	TStatusData statusData;

	statusData.status = NULL;

	statusData.noResponse = EFalse;

	statusData.wasWritten = EFalse;

	statusData.atomicOrSequenceID = 0;

	statusData.performedInAtomic = EFalse;

	statusData.statusIsFixed = EFalse;

	iStatusArray->AppendL( statusData );

	TInt i = iStatusArray->Count() - 1;

	(*iStatusArray)[i].status = new( ELeave ) SmlStatus_t;

	(*iStatusArray)[i].status->elementType = SML_PE_STATUS;

	CopyPcdataL( iMsgRef, (*iStatusArray)[i].status->msgRef );

	return iStatusArray->Count();

	}

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

// CNSmlStatusContainer::SetCmdIDL()

// Sets CmdID element

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

//

void CNSmlStatusContainer::SetCmdIDL( TInt aEntryID, const SmlPcdata_t* aCmdID )

	{

	delete (*iStatusArray)[aEntryID-1].status->cmdID;

	(*iStatusArray)[aEntryID-1].status->cmdID = NULL;

	CopyPcdataL( aCmdID, (*iStatusArray)[aEntryID-1].status->cmdID );

	}

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

// CNSmlStatusContainer::SetMsgRefL()

// Sets MsgRef element

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

//

void CNSmlStatusContainer::SetMsgRefL( TInt aEntryID, const SmlPcdata_t* aMsgRef )

	{

	delete (*iStatusArray)[aEntryID-1].status->msgRef;

	(*iStatusArray)[aEntryID-1].status->msgRef = NULL;

	CopyPcdataL( aMsgRef, (*iStatusArray)[aEntryID-1].status->msgRef );

	}

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

// CNSmlStatusContainer::SetCmdRefL()

// Sets CmdRef element

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

//

EXPORT_C void CNSmlStatusContainer::SetCmdRefL( TInt aEntryID, const SmlPcdata_t* aCmdRef )

	{

	delete (*iStatusArray)[aEntryID-1].status->cmdRef;

	(*iStatusArray)[aEntryID-1].status->cmdRef = NULL;

	CopyPcdataL( aCmdRef, (*iStatusArray)[aEntryID-1].status->cmdRef );

	}

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

// CNSmlStatusContainer::SetCmdL()

// Sets CmdRef element

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

//

EXPORT_C void CNSmlStatusContainer::SetCmdL( TInt aEntryID, const TDesC8& aCmd )

	{

	delete (*iStatusArray)[aEntryID-1].status->cmd;

	(*iStatusArray)[aEntryID-1].status->cmd = NULL;

	CreatePcdataL( (*iStatusArray)[aEntryID-1].status->cmd, aCmd );

	}

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

// CNSmlStatusContainer::SetStatusCodeL()

// Sets Status code to Data element 

// Created element is not pushed to Cleanup stack

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

EXPORT_C void CNSmlStatusContainer::SetStatusCodeL( TInt aEntryID, TInt aStatusCode, TBool aFixStatus )

	{

	//status code in data element

	if ( !(*iStatusArray)[aEntryID-1].statusIsFixed )

		{

		HBufC8* statusCode = HBufC8::NewLC( KNSmlAgentStatusCodeLength );	

		statusCode->Des().Num( aStatusCode );

		if ( !(*iStatusArray)[aEntryID-1].status->data )

			{

			CreatePcdataL( (*iStatusArray)[aEntryID-1].status->data, *statusCode );

			}

		else

			{

			// Don't overwrite status 213 with 200, otherwise replace 

			// existing status

			TInt existingStatus( TNSmlError::ESmlStatusOK );

			TBool ok = StatusCodeVal ( (*iStatusArray)[aEntryID-1].status->data, existingStatus );

			if ( !( ok &&  existingStatus == TNSmlError::ESmlStatusItemAccepted &&

			        aStatusCode == TNSmlError::ESmlStatusOK ) )

		        {

    			delete (*iStatusArray)[aEntryID-1].status->data;

	    		(*iStatusArray)[aEntryID-1].status->data = NULL;

		    	CreatePcdataL( (*iStatusArray)[aEntryID-1].status->data, *statusCode ); 			        

			    }

			}

		if ( aFixStatus)

			{

			(*iStatusArray)[aEntryID-1].statusIsFixed = ETrue;

			}

		}

	CleanupStack::PopAndDestroy(); //statusCode

	}

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

// CNSmlStatusContainer::SetChalL()

// Creates Chal element 

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

void CNSmlStatusContainer::SetChalL( TInt aEntryID, const TDesC8& aNonce )

	{

	(*iStatusArray)[aEntryID-1].status->chal = new( ELeave ) SmlChal_t;

	SmlMetInfMetInf_t* metInf = new( ELeave ) SmlMetInfMetInf_t;

	CleanupStack::PushL( metInf );

	CreatePcdataL( metInf->type, KNSmlAgentAuthMD5 );

	CreatePcdataL( metInf->format, KNSmlAgentBase64Format );

	CreatePcdataL( metInf->nextnonce, aNonce );

	(*iStatusArray)[aEntryID-1].status->chal->meta = new( ELeave ) SmlPcdata_t; 

	(*iStatusArray)[aEntryID-1].status->chal->meta->length = 0;

	(*iStatusArray)[aEntryID-1].status->chal->meta->content = ( TAny* ) metInf;

	CleanupStack::Pop(); //metInf

	(*iStatusArray)[aEntryID-1].status->chal->meta->contentType = SML_PCDATA_EXTENSION;

	(*iStatusArray)[aEntryID-1].status->chal->meta->extension = SML_EXT_METINF;

	}

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

// CNSmlStatusContainer::SetNoResponse

// Sets NoResponse flag 

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

EXPORT_C void CNSmlStatusContainer::SetNoResponse( TInt aEntryID, TBool aNoResponse )

	{

	(*iStatusArray)[aEntryID-1].noResponse = aNoResponse;

	}

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

// CNSmlStatusContainer::SetAtomicOrSequenceId

// Sets Atomic or Sequence Id  

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

EXPORT_C void CNSmlStatusContainer::SetAtomicOrSequenceId( TInt aEntryID, TInt aAtomicOrSequenceID )

	{

	(*iStatusArray)[aEntryID-1].atomicOrSequenceID = aAtomicOrSequenceID;

	}

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

// CNSmlStatusContainer::SetPerformedInAtomic

// Mark an item be performed inside Atomic 

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

EXPORT_C void CNSmlStatusContainer::SetPerformedInAtomic( TInt aEntryID )

	{

	(*iStatusArray)[aEntryID-1].performedInAtomic = ETrue;

	}

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

// CNSmlStatusContainer::SetStatusCodeToAtomicOrSequenceCmdL

// Change status code for Atomic command 

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

EXPORT_C void CNSmlStatusContainer::SetStatusCodeToAtomicOrSequenceCmdL( TInt aAtomicOrSequenceID, TInt aStatusCode, const TDesC8& aCmd )

	{

	TInt arrayCount = iStatusArray->Count();

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

		{

		if ( (*iStatusArray)[i].atomicOrSequenceID == aAtomicOrSequenceID )

			{

			if ( (*iStatusArray)[i].status->cmd )

				{

				if ( (*iStatusArray)[i].status->cmd->content )

					{

					TPtrC8 cmd( (TUint8*) (*iStatusArray)[i].status->cmd->content, (*iStatusArray)[i].status->cmd->length );

					if ( cmd == aCmd )

						{

						SetStatusCodeL( i + 1, aStatusCode );

						break;

						}

					}

				}

			}

		}

	}

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

// CNSmlStatusContainer::SetStatusCodesInAtomicL

// Change status code to all items in Atomic or to items which 

// have been already performed

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

EXPORT_C void CNSmlStatusContainer::SetStatusCodesInAtomicL( TInt aAtomicID, TInt aStatusCode, TBool aOnlyForPerformed )

	{

	TInt arrayCount = iStatusArray->Count();

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

		{

		if ( !(*iStatusArray)[i].atomicOrSequenceID == aAtomicID )

			{

			continue;

			}

		if ( (!aOnlyForPerformed) || ( aOnlyForPerformed && (*iStatusArray)[i].performedInAtomic ) )

			{

			SetStatusCodeL( i + 1, aStatusCode );

			}

		}

	}

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

// CNSmlStatusContainer::AddTargetRefL

// Adds TargetRef element

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

EXPORT_C void CNSmlStatusContainer::AddTargetRefL( TInt aEntryID, const SmlTarget_t* aTarget )

	{

	if ( !aTarget )

		{

		return;

		}

	if ( !aTarget->locURI )

		{

		return;

		}

	if ( !aTarget->locURI->content )

		{

		return;

		}

	SmlTargetRefList_t** targetRefList;

	targetRefList = &(*iStatusArray)[aEntryID-1].status->targetRefList;

	while( *targetRefList )

		{

		targetRefList = &(*targetRefList)->next;

		} 

	*targetRefList = new( ELeave ) SmlTargetRefList_t;

	CreateTargetRefL( aTarget, (*targetRefList)->targetRef ); 

	}

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

// CNSmlStatusContainer::AddSourceRefL

// Adds SourceRef element

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

EXPORT_C void CNSmlStatusContainer::AddSourceRefL( TInt aEntryID, const SmlSource_t* aSource )

	{

	if ( !aSource )

		{

		return;

		}

	if ( !aSource->locURI )

		{

		return;

		}

	if ( !aSource->locURI->content )

		{

		return;

		}

	SmlSourceRefList_t** sourceRefList;

	sourceRefList = &(*iStatusArray)[aEntryID-1].status->sourceRefList;

	while ( *sourceRefList )

		{

		sourceRefList = &(*sourceRefList)->next;

		} 

	*sourceRefList = new( ELeave ) SmlSourceRefList_t;

	CreateSourceRefL( aSource, (*sourceRefList)->sourceRef ); 

	}

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

// CNSmlStatusContainer::AddItemDataL

// Adds Item/Data element 

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

EXPORT_C void CNSmlStatusContainer::AddItemDataL (TInt aEntryID, const SmlPcdata_t* aData )

	{

	SmlItemList_t* newItemList = new( ELeave ) SmlItemList_t;

	CleanupStack::PushL( newItemList );

	newItemList->item = new( ELeave ) SmlItem_t;

	CopyPcdataL( aData, newItemList->item->data );

	SmlItemList_t** itemList;

	itemList = &(*iStatusArray)[aEntryID-1].status->itemList;

	while ( *itemList )

		{

		itemList = &(*itemList)->next;

		}

	*itemList = newItemList;

	CleanupStack::Pop(); //newItemList

	}

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

// CNSmlStatusContainer::RemoveWritten()

// Marks Status command written in outgoing XML document  

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

void CNSmlStatusContainer::RemoveWritten( TInt aEntryID )

	{

	(*iStatusArray)[aEntryID-1].wasWritten = ETrue;

	}

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

// CNSmlStatusContainer::Begin

// Sets index for reading to starting value 

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

EXPORT_C void CNSmlStatusContainer::Begin()

	{

	iArrayInd = -1;

	}

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

// CNSmlStatusContainer::NextStatusElement()

// Returns pointer to the next Status element 

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

EXPORT_C TBool CNSmlStatusContainer::NextStatusElement( SmlStatus_t*& aStatus, TBool aOnlyIfResponse )

	{

	TBool moreElements( ETrue );

	while ( moreElements )

		{

		iArrayInd++;

		if ( iArrayInd > iStatusArray->Count() - 1 )

			{

			RemoveAllWrittenOnes();

			iArrayInd = -1;

			moreElements = EFalse;

			}

		else

			{

			if ( aOnlyIfResponse && (*iStatusArray)[iArrayInd].noResponse )

				{

				}

			else 

			if ( !(*iStatusArray)[iArrayInd].wasWritten )

				{

				aStatus = (*iStatusArray)[iArrayInd].status;

				return ETrue;

				}

			}

		}

	return moreElements;

	}

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

// CNSmlStatusContainer::CurrentEntryID()

// Returns current status ID 

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

TInt CNSmlStatusContainer::CurrentEntryID() const

	{

	return( iArrayInd + 1);

	}

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

// CNSmlStatusContainer::LastEntryID()

// Returns last status ID 

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

EXPORT_C TInt CNSmlStatusContainer::LastEntryID() const

	{

	return iStatusArray->Count();

	}

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

// CNSmlStatusContainer::AnyOtherThanSyncHdrStatus()

// 

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

TBool CNSmlStatusContainer::AnyOtherThanOkSyncHdrStatus() const

	{

	TBool statusPresents = EFalse;

	TInt arrayCount = iStatusArray->Count();

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

		{

		if ( !(*iStatusArray)[i].noResponse )

			{

			if ( (*iStatusArray)[i].status->cmd )

				{

				if ( (*iStatusArray)[i].status->cmd->content )

					{

					TPtrC8 cmd( (TUint8*) (*iStatusArray)[i].status->cmd->content, (*iStatusArray)[i].status->cmd->length );

					if ( cmd == KNSmlAgentSyncHdr )

						{

						if ( (*iStatusArray)[i].status->data )

							{

							if ( (*iStatusArray)[i].status->data->content )

								{

								TPtrC8 statusCode( (TUint8*) (*iStatusArray)[i].status->data->content, (*iStatusArray)[i].status->data->length );

								TLex8 lexicalValue( statusCode );

								TInt statusCodeNum;

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

									{

									if ( statusCodeNum != TNSmlError::ESmlStatusOK &&

										 statusCodeNum != TNSmlError::ESmlStatusAuthenticationAccepted )

										{

										statusPresents = ETrue;

										break;

										}

									}

								}

							}

						}

					else

						{

						statusPresents = ETrue;

						break;

						}

					}

				}

			}

		}	

	return statusPresents;

	}

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

// CNSmlStatusContainer::CreatePcdataL()

// Creates Pcdata 

// Created element is not pushed to Cleanup stack

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

void CNSmlStatusContainer::CreatePcdataL( SmlPcdata_t*& aPcdata, const TDesC8& aContent ) const

	{

	aPcdata = new( ELeave ) SmlPcdata_t;

	aPcdata->SetDataL( aContent );

	aPcdata->contentType = SML_PCDATA_OPAQUE;   

	aPcdata->extension = SML_EXT_UNDEFINED; 

	}

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

// CNSmlStatusContainer::CopyPcdataL()

// Deep copy to Pcdata element

// Copied element is not pushed to Cleanup stack

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

//

void CNSmlStatusContainer::CopyPcdataL( const SmlPcdata_t* aFromPcdata, SmlPcdata_t*& aToPcdata ) const

	{

	aToPcdata = NULL;

	if ( aFromPcdata )

		{

		SmlPcdata_t* newPcdata = new( ELeave ) SmlPcdata_t;

		CleanupStack::PushL( newPcdata );

		newPcdata->length = aFromPcdata->length;

		if (iClearText)

			{

			newPcdata->contentType = SML_PCDATA_STRING;

			}

		else

			{

			newPcdata->contentType = SML_PCDATA_OPAQUE;

			}   

		newPcdata->extension = SML_EXT_UNDEFINED; 

		if ( aFromPcdata->content )

			{

			if ( aFromPcdata->contentType == SML_PCDATA_EXTENSION && aFromPcdata->extension == SML_EXT_METINF )

				{

				newPcdata->contentType = SML_PCDATA_EXTENSION;

				newPcdata->extension = aFromPcdata->extension;