/*

* 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 "CTcSIPContext.h"

#include "SIPConstants.h"

#include "TCmdCreateProfile.h"

#include "CTcSIPProfileContainer.h"

#include <sipmanagedprofile.h>

#include <sipmanagedprofileregistry.h>

#include "tclog.h"

/**

 * INPUT:

 *   Headers:		-

 *   Parameters:	ProfileType*, IapName*, ProfileAORList*, PrivateIdentity*,

 *					ProfileName*, SigComp*, 

 *					AutoRegistration*, SecurityNegotiation*, Server*,

 *					ServerParameter*, ServerExtensionParameter*, 

 *					ExtensionParameter*, ProfileDefault*

 *   IDs:			RegistryId

 *

 * OUTPUT:

 *   Parameters:	-

 *   IDs:			-

 */

void TCmdCreateProfile::ExecuteL()

	{

	// -- Setup ---------------------------------------------------------------

	// Get selected registry

    CTcSIPProfileContainer& container = SelectProfileL();

	// Create a new profile, if type parameter is not found use default 

	// Internet, IETF

	CSIPManagedProfile* profile = NULL;

	CTcStructure* structure = FindStructureL( KParamProfileType, EFalse );

	if( structure )

	    {

	    profile = container.ManagedProfileRegistry().CreateL( ProfileTypeInfoL( structure ) );

	    }

	else

	    {

	    TSIPProfileTypeInfo typeInfo;

	    typeInfo.iSIPProfileClass = TSIPProfileTypeInfo::EInternet;

	    typeInfo.iSIPProfileName = KIETF;

	    profile = container.ManagedProfileRegistry().CreateL( typeInfo );

	    }

	CleanupStack::PushL( profile );

	// -- Execution -----------------------------------------------------------

	SetProfileParamsL( profile );

	// Saving the profile

	container.ManagedProfileRegistry().SaveL( *profile );

	CleanupStack::Pop( profile );

	container.AddManagedProfileL( profile ); //store profile

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

	AddProfileIdResponseL( *profile );

	}

void TCmdCreateProfile::SetProfileParamsL( CSIPManagedProfile* aProfile )

	{

	// Type	

	TcLog::WriteFormat( _L8("-- Get optional structure \"ProfileType\"") );

	CTcStructure* structure = FindStructureL( KParamProfileType, EFalse );

	if( structure )

		{

		TcLog::Write( KLogOk );

	    aProfile->SetType( ProfileTypeInfoL( structure ) );

		}

	else

		{

		TcLog::Write( KLogNotFound );

		}

	// IapId

	TPtrC8 iapname = ExtractTextL( KParamIAPName, EFalse );

	if( iapname != KNullDesC8 )

		{

		TBuf8< KTcMaxTypeName > objectName( iapname );

		TcLog::WriteFormat( _L8("-- Fetching IAP Id for name \"%s\""), objectName.PtrZ() );

		TUint32 iapId = iContext.IAPIdL( iapname );

		User::LeaveIfError( aProfile->SetParameter( KSIPAccessPointId, iapId ) );

		TcLog::Write( KLogOk );

		}

	// AORs

	TcLog::WriteFormat( _L8("-- Get optional array \"ProfileAORList\"") );

	CTcArray* aorsArr = FindArrayL( KParamProfileAORs, EFalse );

	if( aorsArr )

		{

		// Use first item of aorsArr

		TPtrC8 aor = aorsArr->AsMDesCArray().MdcaPoint( 0 );

		if( aor != KNullDesC8 )

		    {

    		TcLog::Write( KLogOk );

    		User::LeaveIfError( aProfile->SetParameter( KSIPUserAor, aor ) );

		    }

		}

	else

		{

		TcLog::Write( KLogNotFound );

		}

    // Headers

	TcLog::WriteFormat( _L8("-- Get optional array \"ProfileHeadersList\"") );

	CTcArray* headersArr = FindArrayL( KParamProfileHeaders, EFalse );

	if( headersArr )

		{

    	TcLog::Write( KLogOk );

    	User::LeaveIfError( aProfile->SetParameter( KSIPHeaders, headersArr->AsMDesCArray() ) );

		}

	else

		{

		TcLog::Write( KLogNotFound );

		}

	// Header params

	TcLog::WriteFormat( _L8("-- Get optional array \"ProfileHeaderParamsList\"") );

	CTcArray* headerParamsArr = FindArrayL( KParamProfileHeaderParams, EFalse );

	if( headerParamsArr && headerParamsArr->Count() > 0 )

		{

    	TcLog::Write( KLogOk );

    	TUint32 paramType( 0 );

	    TLex8 lexer( headerParamsArr->Item( 0 ) );

	    User::LeaveIfError( lexer.Val( paramType, EDecimal ) );

    	headerParamsArr->RemoveItem( 0 );

    	User::LeaveIfError( aProfile->SetParameter( paramType, headerParamsArr->AsMDesCArray() ) );

		}

	else

		{

		TcLog::Write( KLogNotFound );

		}

	// PrivateIdentity

	TPtrC8 privateIdentity = ExtractTextL( KParamProfilePrivateIdentity, EFalse );

	if( privateIdentity != KNullDesC8 )

		{

		User::LeaveIfError( aProfile->SetParameter( KSIPPrivateIdentity, privateIdentity ) );

		}

	// Name

	TPtrC8 name = ExtractTextL( KParamProfileName, EFalse );

	if( name != KNullDesC8 )

		{

		User::LeaveIfError( aProfile->SetParameter( KSIPProviderName, name ) );

		}

	// SigComp	

	if( HasBooleanL( KParamProfileSigComp ) )

	    {

    	User::LeaveIfError( aProfile->SetParameter( KSIPSigComp, 

    	                                            ExtractBooleanL( KParamProfileSigComp, EFalse ) ) );

	    }

	// AutoRegistration

	if( HasBooleanL( KParamProfileAutoRegistration ) )

	    {

	    User::LeaveIfError( aProfile->SetParameter( KSIPAutoRegistration, 

	                                                ExtractBooleanL( KParamProfileAutoRegistration, EFalse ) ) );

	    }

	// SecurityNegotiation

	if( HasBooleanL( KParamProfileSecurityNegotiation ) )

	    {

    	User::LeaveIfError( aProfile->SetParameter( KSIPSecurityNegotiation, 

    	                                            ExtractBooleanL( KParamProfileSecurityNegotiation, EFalse ) ) );

	    }

	// Server

	do

		{

		structure = FindStructureL( KParamProfileServer, EFalse );

		if( structure )

			{

            User::LeaveIfError( aProfile->SetParameter( 

			                        ServerL( structure ), 

			                        KSIPServerAddress,

			                        structure->ItemL( KParamProfileAddress )->Value() ) );

			iContext.List().RemoveParameter( KParamProfileServer );

			}

		} while( structure );

	// ServerParameter

	do

		{

		structure = FindStructureL( KParamProfileServerParameter, EFalse );

		if( structure )

			{

			User::LeaveIfError( aProfile->SetParameter( ServerL( structure ),

										   ServerParameterL( structure ),

										   structure->ItemL( 1 )->Value() ) );

			iContext.List().RemoveParameter( KParamProfileServerParameter );

			}

		} while( structure );

	// ServerExtensionParameter

	do

		{

		structure = FindStructureL( KParamProfileServerExtensionParameter, EFalse );

		if( structure )

			{

			CTcNameValue* item = structure->ItemL( 1 );

			User::LeaveIfError( aProfile->SetParameter( ServerL( structure ),

												        item->NameAsIntL(), item->Value() ) );

			iContext.List().RemoveParameter( KParamProfileServerExtensionParameter );

			}

		} while( structure );

	// ExtensionParameter

	do

		{

		structure = FindStructureL( KParamProfileExtensionParameter, EFalse );

		if( structure )

			{

			const CTcNameValue* item = structure->ItemL( 0 );

			TInt extInt( 0 );

			TRAPD( err, extInt = item->ValueAsIntL() );

			if ( !err )

			    {

			    User::LeaveIfError( 

			        aProfile->SetParameter( item->NameAsIntL(), 

			                                static_cast<TUint32>( extInt ) ) );

			    }

			else

			    {

			    TBool extBool( EFalse );

			    TRAPD( err2, extBool = item->ValueAsBooleanL() );

			    if ( !err2 )

			        {

			        User::LeaveIfError( aProfile->SetParameter( item->NameAsIntL(), extBool ) );

			        }

			    else

    			    {

    			    User::LeaveIfError( aProfile->SetParameter( item->NameAsIntL(), item->Value() ) );

    			    }

			    }

			iContext.List().RemoveParameter( KParamProfileExtensionParameter );

			}

		} while( structure );

	// Default

	if( ExtractBooleanL( KParamProfileDefault, EFalse ) )

	    {

	    // Can set only to true

	    User::LeaveIfError( aProfile->SetParameter( KSIPDefaultProfile, ETrue ) );

	    }

	}

TBool TCmdCreateProfile::Match( const TTcIdentifier& aId )

	{

	return TTcSIPCommandBase::Match( aId, _L8("CreateProfile") );

	}

TTcCommandBase* TCmdCreateProfile::CreateL( MTcTestContext& aContext )

	{

	return new( ELeave ) TCmdCreateProfile( aContext );

	}

TUint32 TCmdCreateProfile::ServerL( CTcStructure* aStruct )

	{

	TUint32 server( KSIPRegistrar );

	TPtrC8 value = aStruct->ItemL( KParamProfileServer )->Value();

	if( value == KRegistrar )

		{

		server = KSIPRegistrar;

		}

	else if( value == KOutboundProxy )

		{

		server = KSIPOutboundProxy;

		}

	else

		{

		User::Leave( KTcErrMandatoryStructureItemNotFound );

		}

	return server;

	}

TUint32 TCmdCreateProfile::ServerParameterL( CTcStructure* aStruct )

	{

	TUint32 serverParameter = KSIPDigestRealm;

	TPtrC8 value = aStruct->ItemL( 1 )->Name();

	if( value == KDigestRealm )

		{

		serverParameter = KSIPDigestRealm;

		}

	else if( value == KDigestUsername )

		{

		serverParameter = KSIPDigestUserName;

		}

	else if( value == KDigestPassword )

	    {

	    serverParameter = KSIPDigestPassword;

	    }

	else

		{

		User::Leave( KTcErrMandatoryStructureItemNotFound );

		}

	return serverParameter;

	}

TSIPProfileTypeInfo TCmdCreateProfile::ProfileTypeInfoL( CTcStructure* aStruct )

    {

	TSIPProfileTypeInfo typeInfo;

	TcLog::WriteFormat( _L8("-- Get mandatory structure item \"ProfileName\"") );

	typeInfo.iSIPProfileName = aStruct->ItemL( KParamProfileName )->Value();

	TcLog::Write( KLogOk );

	typeInfo.iSIPProfileClass = ProfileTypeClassL( aStruct );

    return typeInfo;

    }

TSIPProfileTypeInfo::TSIPProfileClass 

    TCmdCreateProfile::ProfileTypeClassL( CTcStructure* aStruct )

	{

	TcLog::WriteFormat( _L8("-- Get mandatory structure item \"Class\"") );

	TSIPProfileTypeInfo::TSIPProfileClass typeClass = TSIPProfileTypeInfo::EInternet;

	TPtrC8 value = aStruct->ItemL( KParamProfileClass )->Value();

	if( value == KInternet )

		{

		typeClass = TSIPProfileTypeInfo::EInternet;

		}

	else if( value == KIms )

		{

		typeClass =  TSIPProfileTypeInfo::EIms;

		}

	else if( value == KOther )

		{

		typeClass =  TSIPProfileTypeInfo::EOther;

		}

	else

		{

		User::Leave( KTcErrMandatoryStructureItemNotFound );

		}

	TcLog::Write( KLogOk );

	return typeClass;

	}