/*

* Copyright (c) 2004 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:    Implementation.

*

*/

#include "CTcMCEContext.h"

#include "MCEConstants.h"

#include "TTcMceCommandBase.h"

#include "CTcMCEProfileContainer.h"

#include <MCESession.h>

#include <MCEEvent.h>

#include <MCERefer.h>

#include <MceMediaStream.h>

TTcMceCommandBase::TTcMceCommandBase( MTcTestContext& aContext )

	: TTcCommandBase( static_cast< CTcContextBase& >( aContext ) ),

	  iContext( static_cast< CTcMCEContext& >( aContext ) ),

	  iPushed( 0 )

	{

	}

//

// - Parameter extraction functions -------------------------------------------

//

TInt TTcMceCommandBase::ExtractProfileIdL()

    {

    TPtrC8 profileIdStr = ExtractIdL( KParamProfileId );

	TInt profileId( 0 );

	TLex8 lexer( profileIdStr );

	User::LeaveIfError( lexer.Val( profileId ) );

	return profileId;

    }

CSIPProfile& TTcMceCommandBase::GetProfileL( CTcMCEProfileContainer& aProfileContainer )

	{

	// Get profile from the registry

    return aProfileContainer.GetProfileByIdL( ExtractProfileIdL() );

	}

CTcMCEProfileContainer& TTcMceCommandBase::SelectProfileL()

	{

	TPtrC8 value = ExtractIdL( KRegistryId, EFalse );

	if( value != KNullDesC8 )

		{

		CTcMCEProfileContainer* conn

							= reinterpret_cast< CTcMCEProfileContainer* >(

								iContext.Registry().ObjectPtrL( value ) );

		return *conn;

		}

	else

		{

		return iContext.Profile();

		}

	}

CDesC8Array* TTcMceCommandBase::ExtractArrayL( const TDesC8& aName,

											   TBool aIsMandatory ) 

	{

	CTcArray* tcArray = FindArrayL(aName, aIsMandatory);

	if ( !tcArray )

		{

		return NULL;

		}

	CDesC8Array* array = new(ELeave)CDesC8ArraySeg(1);

	CleanupStack::PushL( array );

	const MDesC8Array& aItems = tcArray->AsMDesCArray(); 

	TInt count = aItems.MdcaCount();

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

		{

		array->AppendL( aItems.MdcaPoint( i ) );

		}

	CleanupStack::Pop( array );	

	return array;			

	}

CDesC8Array* TTcMceCommandBase::ExtractHeadersL( TBool aIsMandatory ) 

	{

	CDesC8Array* array = ExtractArrayL(KParamSipHeaders, aIsMandatory );

	if ( array )

		{

		if ( array->Count() > 0 )

			{

			return array;

			}

		}

	delete array;

	return NULL;

	}

HBufC8* TTcMceCommandBase::HBufCParameterL( TPtrC8 ptr )

	{

	HBufC8* buf = NULL;

	// MCE API should accept null parameters, but as long as it does not,

	// zero-length descriptors are used instead. When problem is corrected,

	// remove comments.

	//if (ptr != KNullDesC8 )

	//	{

		buf = ptr.AllocL();

	//	}	

	return buf;

	}

//

// - Response creation functions ----------------------------------------------

//

CTcStructure& TTcMceCommandBase::FindCreateTestClientIdsL()

	{

	// Find the TestClientIds structure, it may be in several places

	// (there might already be a ReceivedMsg item in the return list)

	// It may also be missing altogether, if this is the first time

	// AddIdResponseL() is called.

	TInt pos = iContext.ReturnList().FindParameter( KResponseTestClientIds,

													MTcTyped::EStructure );

	if( pos == KErrNotFound )

		{

		// Figure out the correct position for the structure: just

		// after the ReceivedMsg if it exists.

		pos = iContext.ReturnList().FindParameter( KResponseHeaders,

												   MTcTyped::EArray );

		if( pos == KErrNotFound )

			{

			pos = 0;	// no headers, insert at the beginning

			}

		else

			{

			pos++;	// insert after headers

			}

		// Add a structure to the response parameter list for TestClient Ids

		CTcStructure* tcIDs = CTcStructure::NewLC();

		tcIDs->SetName( KResponseTestClientIds );

		iContext.ReturnList().InsertParameterL( tcIDs, pos );

		CleanupStack::Pop( tcIDs);

		// All IDs, in no spesific order (in alphabetical order in SIPTester)

        // (this has to be function-local in order to compile for THUMB)

		// Confirm that you don't have comma after last Id!

		const TDesC8* const TIdNames[] = {

			&KProfileObj, // Profile's name in TesterCores registry

			&KSessionId,

			&KEventId,

			&KReferId,

			&KStreamId,

			&KCodecId,

			&KSourceId,

			&KSinkId

			};

		// Add an entry for ALL possible Ids. This is done to go around

		// a Telelogic Tau logging problem related to template mismatches

		TInt count = sizeof( TIdNames ) / sizeof( const TDesC8* );

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

			{

			CTcNameValue* nameValue = CTcNameValue::NewLC();

			nameValue->SetL( *TIdNames[ i ], 0 );

			tcIDs->AddItemL( nameValue );

			CleanupStack::Pop( nameValue );

			}

		}

	return iContext.ReturnList().AsStructure( pos );

	}

void TTcMceCommandBase::AddIdResponseL( const TDesC8& aName,

										const CBase* aObject )

	{

	// Register object and fetch its name

	iContext.Registry().AddObjectL(	const_cast< CBase* >( aObject ) );

	TPtrC8 idName = iContext.Registry().ObjectNameL( aObject );	

	CTcStructure& tcIDs = FindCreateTestClientIdsL();

	CTcNameValue* idNameValue = tcIDs.ItemL( aName );

	idNameValue->SetValueL( idName );

	}

void TTcMceCommandBase::AddIdResponseL( const TDesC8& aName,

										const CBase& aObject )

	{

	// Register object and fetch its name

	iContext.Registry().AddObjectL(	aObject );

	TPtrC8 idName = iContext.Registry().ObjectNameL( &aObject );

	CTcStructure& tcIDs = FindCreateTestClientIdsL();

	CTcNameValue* idNameValue = tcIDs.ItemL( aName );

	idNameValue->SetValueL( idName );

	}

void TTcMceCommandBase::AddHeadersL( const CDesC8Array* aHeaders ) 

	{

	if ( aHeaders ) 

		{

		if ( aHeaders->Count() > 0 )

			{

			AddArrayResponseL( KResponseHeaders, *aHeaders );

			}

		}

	}

void TTcMceCommandBase::AddTextualSessionStateL( TInt aState) 

	{

	switch( aState ) 

		{

		case CMceSession::EIdle: AddTextResponseL(KResponseStateText, KIdle); break;

		case CMceSession::EOffering: AddTextResponseL(KResponseStateText, KOffering); break;

		case CMceSession::EIncoming: AddTextResponseL(KResponseStateText, KIncoming); break;

		case CMceSession::EAnswering: AddTextResponseL(KResponseStateText, KAnswering); break;

		case CMceSession::EProceeding: AddTextResponseL(KResponseStateText, KProceeding); break;

		case CMceSession::EEstablished: AddTextResponseL(KResponseStateText, KEstablished); break;

		case CMceSession::EReserving: AddTextResponseL(KResponseStateText, KUpdating); break;

		case CMceSession::ECancelling: AddTextResponseL(KResponseStateText, KCancelling); break;

		case CMceSession::ETerminating: AddTextResponseL(KResponseStateText, KTerminating); break;

		case CMceSession::ETerminated: AddTextResponseL(KResponseStateText, KTerminated); break;

		//case CMceSession::EOnHold: AddTextResponseL(KResponseStateText, KOnHold); break;

		//case CMceSession::EReferred: AddTextResponseL(KResponseStateText, KReferred); break;

		default: AddTextResponseL(KResponseStateText, KUnknownState); break;

		}

	}

void TTcMceCommandBase::AddTextualMediaStreamStateL( TInt aState) 

	{

	switch( aState ) 

		{

		case CMceMediaStream::EUninitialized: AddTextResponseL(KResponseMediaStreamStateText, KUninitialized); break;

		case CMceMediaStream::EInitialized: AddTextResponseL(KResponseMediaStreamStateText, KInitialized); break;

		case CMceMediaStream::EBuffering: AddTextResponseL(KResponseMediaStreamStateText, KBuffering); break;

		//case CMceMediaStream::EIdle: AddTextResponseL(KResponseMediaStreamStateText, KIdle); break;

		case CMceMediaStream::EIdle: AddTextResponseL(KResponseMediaStreamStateText, KmsIdle); break;

		case CMceMediaStream::EStreaming: AddTextResponseL(KResponseMediaStreamStateText, KStreaming); break;

		case CMceMediaStream::EDisabled: AddTextResponseL(KResponseMediaStreamStateText, KDisabled); break;

		case CMceMediaStream::ENoResources: AddTextResponseL(KResponseMediaStreamStateText, KNoResources); break;

		case CMceMediaStream::ETranscodingRequired: AddTextResponseL(KResponseMediaStreamStateText, KTranscodingRequired); break;

		case CMceMediaStream::ETranscoding: AddTextResponseL(KResponseMediaStreamStateText, KTranscoding); break;

		default: AddTextResponseL(KResponseMediaStreamStateText, KUnknownState); break;

		}

	}	

// MediaStream state is removed. There are only 2 state enable and disable

void TTcMceCommandBase::AddTextualStreamStateL( TBool aState, TBool aBound ) 

	{

	TPtrC8 addedText;

	if ( aBound )

	    {

	    addedText.Set(KResponseBoundStreamStateText);

	    }

	else

	    {

	    addedText.Set(KResponseStreamStateText);

	    }

	if ( aState)

		{

		AddTextResponseL( addedText, KStreamEnable);	

		}

	else

		{

		AddTextResponseL( addedText, KStreamDisable);		

		}

	}

void TTcMceCommandBase::AddTextualEventStateL( TInt aState ) 

	{

	switch( aState ) 

		{

		case CMceEvent::EIdle: 

			{

			AddTextResponseL(KResponseEventStateText, KIdle); 

			break;

			}

		case CMceEvent::EPending: 

			{

			AddTextResponseL(KResponseEventStateText, KPending); 

			break;

			}

		case CMceEvent::EActive: 

			{	

			AddTextResponseL(KResponseEventStateText, KActive); 

			break;

			}

		case CMceEvent::ETerminated: 

			{

			AddTextResponseL(KResponseEventStateText, KTerminated); 

			break;

			}

		default: 

			{

			AddTextResponseL(KResponseEventStateText, KUnknownState); 

			break;

			}

		}

	}

void TTcMceCommandBase::AddTextualReferStateL( TInt aState ) 

	{

	switch( aState ) 

		{

		case CMceRefer::EIdle: 

			{

			AddTextResponseL(KResponseReferStateText, KIdle); 

			break;

			}

		case CMceRefer::EAccepted: 

			{	

			AddTextResponseL(KResponseReferStateText, KAccepted); 

			break;

			}

		case CMceRefer::ETerminated: 

			{

			AddTextResponseL(KResponseReferStateText, KTerminated); 

			break;

			}

		default: 

			{

			AddTextResponseL(KResponseReferStateText, KUnknownState); 

			break;

			}

		}

	}