/*

* Copyright (c) 2002-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 of customization components

*

*/

// INCLUDE FILES

#include "TestParams.h"

//#include <e32svr.h>

#include <StifLogger.h>

#include <StifItemParser.h>

//#include <Stiftestinterface.h>

//#include "ThemesTest.h"

#include "TestDmCallback.h"

#include "TestDmDDFObject.h"

#include "FileCoderB64.h"

#include "nsmldmuri.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

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

// CTestParams::CTestParams

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CTestParams::CTestParams( CStifLogger *aLog )

	: iLog( aLog )

//	, iStr( 0 )

	, iUri( 0 )

	, iData( 0 )

	, iDataType( 0 )

	, iOutputFile( 0 )

	, iExpectedStatus( -1 )

	, iExpectedData( 0 )

	, iExpectedType( 0 )

	, iStatusRef( -1 )

	, iResultsRef( -1 )

	{

	/**/

	}

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

// CTestParams::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTestParams::ConstructL( CStifItemParser& aItem )

	{

	// Parse parameters

	TPtrC str;

    TInt ret = aItem.Remainder( str );

	TBuf8<200> buf;

	buf.Copy( str )    ;

	iLog->Log( _L("CmdParams: '%S'"), &str );

//	TInt i = 0;	

//	while (aItem.GetNextString( str ) == KErrNone )	

//		{

//		iLog->Log( _L("Par[%d]: '%S'"), i, &str );

//		}

//	iLog->Log( _L("Version is")) ;

//	iLog->Log( version->Ptr(0) ) ;

//	

//			iLog->Log( _L("Add Test Adding Policy data failed! %d" ), iStatus );	

	TTestParamVar var( buf );

	while (var.Next())

		{

		TPtrC8 key = var.Name();

		TPtrC8 value = var.Value();

		TBool exist = var.ValueExist();

		iLog->Log(_L8("key: '%S', value: '%S', exist: %d"), &key, &value, exist);

/*

		Syntax:

		-------

		URI=

		File=

		Text=

		IT= Input (text)

		IF= Input File (filename)

		OF= Output File

		ET= Expected result (text)

		EF= Expected file (filename)

*/

		_LIT8( KURI,			"URI" ); // = value

		_LIT8( KText,			"Text" ); // = "Text input"

		_LIT8( KFile,			"File" ); // = Filename (and path)

		_LIT8( KType,			"Type" ); // = MimeType (of data)

		_LIT8( KInputText,		"IT" ); // = "Input Text"

		_LIT8( KInputFile,		"IF" ); // = InputFileName (and path)

		_LIT8( KInputFile2,		"IF2" ); // = InputFileName (and path)

		_LIT8( KInputType,		"IM" ); // = Input MimeType (of data)

		_LIT8( KOutputFile,		"OF" ); // = OutputFileName (and path) (where result data is saved)

		_LIT8( KExpectedStatus,	"ES" ); // = <Expected Status Code>

		_LIT8( KExpectedText,	"ET" ); // = "Expected Result Text"

		_LIT8( KExpectedFile,	"EF" ); // = ExpectedResultFile (and path)

		_LIT8( KExpectedFile2,	"EF2" ); // = ExpectedResultFile (and path)

		_LIT8( KExpectedType,	"EM" ); // = Expected MimeType (of return data)

//	, iUri( 0 )

//	, iData( 0 )

//	, iDataType( 0 )

		if ( key.CompareF( KURI ) == 0 )

			{

			if (iUri == 0)

				{

				delete iUri;

				iUri = 0;

				iUri = value.AllocL();

				}

			else

				{

				iLog->Log(_L8("Warning: URI already given, not resetting to: '%S'"), &value );

				}

			}

		else if ( key.CompareF( KInputText ) == 0 || key.CompareF( KText ) == 0 )

			{

			delete iData;

			iData = 0;

			iData = value.AllocL();

			}

		else if ( key.CompareF( KInputFile ) == 0 || key.CompareF( KFile ) == 0 )

			{

			delete iData;

			iData = 0;

			TFileCoderB64 coder;

			User::LeaveIfError( coder.EncodeL( value, iData ) );

			}

		else if ( key.CompareF( KInputFile2) == 0 )

			{

			delete iData;

			iData = 0;

            RFs fs; fs.Connect();

            TFileName fn; fn.Copy(value);

            RFile f; f.Open(fs, fn, EFileShareExclusive|EFileRead);

            TInt size; f.Size( size );

            iData = HBufC8::NewL( size );

            TPtr8 ptr( iData->Des() );

            f.Read( ptr );

			f.Close();

			fs.Close();

			}

		else if ( key.CompareF( KInputType ) == 0 || key.CompareF( KType ) == 0 )

			{

			delete iDataType;

			iDataType = 0;

			iDataType = value.AllocL();

			}

		else if (key.CompareF( KOutputFile ) == 0 )

			{

			delete iOutputFile;

			iOutputFile = 0;

			iOutputFile = value.AllocL();

			}

		else if (key.CompareF( KExpectedStatus ) == 0 )

			{

			TLex8 lex( value );

			User::LeaveIfError( lex.Val( iExpectedStatus ) );

			}

		else if (key.CompareF( KExpectedText ) == 0 )

			{

			delete iExpectedData;

			iExpectedData = 0;

			iExpectedData = value.AllocL();

			}

		else if (key.CompareF( KExpectedFile ) == 0 )

			{

			delete iExpectedData;

			iExpectedData = 0;

			TFileCoderB64 coder;

			User::LeaveIfError( coder.EncodeL( value, iExpectedData ) );

			}

		else if (key.CompareF( KExpectedFile2 ) == 0 )

			{

			delete iExpectedData;

			iExpectedData = 0;

            RFs fs; fs.Connect();

            TFileName fn; fn.Copy(value);

            RFile f; f.Open(fs, fn, EFileShareExclusive|EFileRead);

            TInt size; f.Size( size );

            iExpectedData = HBufC8::NewL( size );

            TPtr8 ptr( iExpectedData->Des() );

            f.Read( ptr );

			f.Close();

			fs.Close();

			}

		else if (key.CompareF( KExpectedType ) == 0 )

			{

			delete iExpectedType;

			iExpectedType = 0;

			iExpectedType = value.AllocL();

			}

		else

			{

			// Unknown parameter

			iLog->Log(_L8("Warning: Unknown parameter: key: '%S', value: '%S', exist: %d"), &key, &value, exist);

			}

		}

	// Cleanup

	}

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

// CTestParams::NewL

// Two-phased constructor.

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

//

CTestParams* CTestParams::NewL( CStifLogger *aLog, CStifItemParser& aItem )

	{

    CTestParams* self = NewLC( aLog, aItem );

    CleanupStack::Pop( self );

    return self;

	}

CTestParams* CTestParams::NewLC( CStifLogger *aLog, CStifItemParser& aItem )

	{

    CTestParams* self = new (ELeave) CTestParams( aLog );

    CleanupStack::PushL( self );

    self->ConstructL( aItem );

    return self;

	}

// Destructor

CTestParams::~CTestParams()

	{

	/**/

	delete iUri;

	delete iData;

	delete iDataType;

	delete iOutputFile;

	delete iExpectedData;

	delete iExpectedType;

	}

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

// CTestParams::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

/*?type CTestParams::?member_function(

    ?arg_type arg,

    ?arg_type arg )

    {

    ?code

    }

*/

/*

void CTestParams::SetL( CStifItemParser& aItem )

	{

//	iString = aItem.

	TPtrC str;

    TInt ret = aItem.Remainder( str );

	}

*/

const TDesC8& CTestParams::Uri()

	{

	if (iUri != 0)

		{

		return *iUri;

		}

	else

		{

		return KNullDesC8;

		}

	}

const TDesC8& CTestParams::Data()

	{

	if (iData != 0)

		{

		return *iData;

		}

	else

		{

		return KNullDesC8;

		}

	}

const TDesC8& CTestParams::DataType()

	{

	if (iDataType != 0)

		{

		return *iDataType;

		}

	else

		{

		return KNullDesC8;

		}

	}

//sf-void CTestParams::SetCallback( CTestDmCallback* aCallback )

//sf-	{

//sf-	iCallback = aCallback;

//sf-	}

void CTestParams::SetResultsRef( TInt aResultsRef )

	{

	iResultsRef = aResultsRef;

	}

void CTestParams::SetStatusRef( TInt aStatusRef )

	{

	iStatusRef = aStatusRef;

	}

//sf-TInt CTestParams::CheckStatusL( MSmlDmAdapter::TError aStatus )

TInt CTestParams::CheckStatusL( TInt aStatus )

	{

	TInt ret = KErrNone;

	if (iExpectedStatus >= 0 && iExpectedStatus != aStatus)

		{

		iLog->Log( _L8("Error: CTestParams::CheckStatusL: expected=%d, status=%d"), iExpectedStatus, aStatus );

		ret = KErrGeneral;

		}

	return ret;

	}

TInt CTestParams::CheckDataL( CBufFlat& aObject )

	{

	TPtrC8 ptr = aObject.Ptr(0);

	TInt ret = CheckDataL( ptr );

	return ret;

/*

	TInt ret = KErrNone;

	if (iExpectedData)

		{

		TPtrC8 ptr = aObject.Ptr(0);

		if (iExpectedData->Compare( ptr ) != 0)

			{

			iLog->Log( _L8("Error: CTestParams::CheckDataL") );

			ret = KErrGeneral;

			}

		}

	return ret;

*/

	}

TInt CTestParams::CheckDataL( const TDesC8& aObject )

	{

	TInt ret = KErrNone;

	if (iExpectedData)

		{

		TInt len1 = iExpectedData->Length();

		TInt len2 = aObject.Length();

		if (iExpectedData->Compare( aObject ) != 0)

			{

			TPtrC8 expt = iExpectedData->Left( 80 );

			TPtrC8 real = aObject.Left( 80 );

//sf-			iLog->Log( _L8("Error: CTestParams::CheckDataL") );

			iLog->Log( _L8("Error: CTestParams::CheckDataL: expected='%S', real='%S'"), &expt, &real );

			ret = KErrGeneral;

			}

		}

	return ret;

	}

TInt CTestParams::CheckTypeL( const TDesC8 &aType )

	{

	TInt ret = KErrNone;

	if (iExpectedType)

		{

		if (iExpectedType->CompareF( aType ) != 0)

			{

			iLog->Log( _L8("Error: CTestParams::CheckTypeL: exp='%S', typ='%S'"), iExpectedType, &aType );

			ret = KErrGeneral;

			}

		}

	return ret;

	}

TInt CTestParams::CheckL( CTestDmCallback* aCallback )

	{

	TInt ret = KErrNone;

//	MSmlDmAdapter::TError status = EOk;

//		const CBufBase& GetResultsObjectL( TInt aResultsRef );

//		const TDesC8& GetResultsTypeL( TInt aResultsRef );

	if (iStatusRef >= 0)

		{

		MSmlDmAdapter::TError status = aCallback->GetStatusL( iStatusRef );

		TInt ret1 = CheckStatusL( status );

		ret = (ret != KErrNone) ? ret : ret1;

		}

	else

		{

//		iLog->"Error: StatusRef not set"

		}

	if (iResultsRef >= 0)

		{

		const CBufBase& tmpObject = aCallback->GetResultsObjectL( iResultsRef );

		TInt ret1 = CheckDataL( *(CBufFlat*) &tmpObject );

		TPtrC8 tmpType = aCallback->GetResultsTypeL( iResultsRef );

		TInt ret2 = CheckTypeL( tmpType );

		// choose first error code

		ret = (ret != KErrNone) ? ret : ret1;

		ret = (ret != KErrNone) ? ret : ret2;

		}

	else

		{

//		iLog->"Note: ResultsRef not set"

		}

	return ret;

	}

TInt CTestParams::CheckStatusRefL( TInt aStatusRef )

	{

	TInt ret = KErrNone;

	if (iExpectedStatus)

		{

		}

	return ret;

	}

TInt CTestParams::CheckResultsRefL( TInt aResultsRef )

	{

	TInt ret = KErrNone;

	if (iExpectedStatus)

		{

		}

	return ret;

	}

//******************************************************************************

//

//

//

//******************************************************************************