/*

* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#include <test/testexecutelog.h>

#include <s32mem.h>

#include "cafserver.h"

#include "SupplierStep.h"

#include "supplier.h"

#include "cafmimeheader.h"

#include "caferr.h"

#include "metadataarray.h"

#include "supplieroutputfile.h"

#include "attribute.h"

#include "bitset.h"

#include <uri8.h>

#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY

#include <http.h>

#include <http/rhttpsession.h>

#include <http/rhttptransaction.h>

#include <http/rhttpheaders.h>

#endif

using namespace ContentAccess;

/* 

 * This step imports a DCF file into CAF 

 *

 */

CCafSupplierStep::~CCafSupplierStep()

	{

	}

CCafSupplierStep::CCafSupplierStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFSupplierStep);

	}

TVerdict CCafSupplierStep::doTestStepL()

	{

	SetTestStepResult(EInconclusive);

	RFs fs;

	RFile file;

	TBuf8 <128> readBuffer;

	INFO_PRINTF1(_L("Supplier Test - Agent provides output files"));

	TPtrC outputDirectory, sourceFileName, suggestedFileName, mimeType;

	TInt expectedLeave;

	// Get parameters from INI file

	GetStringFromConfig(ConfigSection(),_L("OutputPath"),outputDirectory);

	GetStringFromConfig(ConfigSection(),_L("SourceFileName"),sourceFileName);

	GetStringFromConfig(ConfigSection(),_L("SuggestedFileName"),suggestedFileName);

	GetStringFromConfig(ConfigSection(),_L("MimeType"),mimeType);

	GetIntFromConfig(ConfigSection(),_L("LeaveResult"),expectedLeave);

	StartApparcServerL();

	__UHEAP_MARK;

	HBufC8 *mime = ConvertDes16toHBufC8LC(mimeType);

	CCafMimeHeader *header = CCafMimeHeader::NewL(mime->Des());

	CleanupStack::PushL(header);

	CSupplier *mySupplier = CSupplier::NewLC();

	mySupplier->SetOutputDirectoryL(outputDirectory);

	// ignore return value, just exercises code for CCover

	mySupplier->IsImportSupported(header->StandardMimeData(EContentType));

	CImportFile *import = NULL;

	TRAPD(leaveResult, import = mySupplier->ImportFileL(*header, suggestedFileName));

	if(leaveResult != expectedLeave)

		{

		SetTestStepResult(EFail);

		}

	if(leaveResult == KErrNone)

		{

		CleanupStack::PushL(import);

		// read the input file and pass it to the CAF

		fs.Connect();

		CleanupClosePushL(fs);

		TInt result = file.Open(fs, sourceFileName, EFileRead | EFileStream | EFileShareAny);

		CleanupClosePushL(file);

		while(result == KErrNone)

			{

			result = file.Read(readBuffer);

			if(readBuffer.Length() == 0)

				break;

			User::LeaveIfError(import->WriteData(readBuffer));

			}

		CleanupStack::PopAndDestroy(&file); 

		User::LeaveIfError(import->WriteDataComplete());

		TInt n = import->OutputFileCountL();

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

			{

			// get output file name

			TPtrC OutputFileName = import->OutputFileL(i).FileName();

			INFO_PRINTF2(_L("Output File Created: %S"),&OutputFileName);

			// get output file type (content or receipt)

			TOutputType outputType = import->OutputFileL(i).OutputType();

			if(outputType == EReceipt)

				{

				INFO_PRINTF1(_L("Output File is a receipt"));

				}

			else

				{

				INFO_PRINTF1(_L("Output File is content"));

				}

			// get output file mime type

			TPtrC8 OutputMimeType = import->OutputFileL(i).MimeTypeL();

			HBufC *mime = ConvertDes8toHBufC16LC(OutputMimeType );

			INFO_PRINTF2(_L("Output File Mime Type: %S"),mime);

			CleanupStack::PopAndDestroy(mime); 

			}

		CleanupStack::PopAndDestroy(&fs); 

		CleanupStack::PopAndDestroy(import); 

		}

	CleanupStack::PopAndDestroy(mySupplier); 

	CleanupStack::PopAndDestroy(header); 

	CleanupStack::PopAndDestroy(mime); 

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

/* 

 * This step imports a DCF file into CAF 

 *

 */

CCafSupplierAsyncStep::~CCafSupplierAsyncStep()

	{

	}

CCafSupplierAsyncStep::CCafSupplierAsyncStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFSupplierAsyncStep);

	}

TVerdict CCafSupplierAsyncStep::doTestStepL()

	{

	SetTestStepResult(EInconclusive);

	RFs fs;

	RFile file;

	TBuf8 <128> readBuffer;

	TRequestStatus status;

	INFO_PRINTF1(_L("Asynchronous Supplier Test - Agent provides output files"));

	TPtrC outputDirectory, sourceFileName, suggestedFileName, mimeType;

	TInt expectedLeave;

	// Get parameters from INI file

	GetStringFromConfig(ConfigSection(),_L("OutputPath"),outputDirectory);

	GetStringFromConfig(ConfigSection(),_L("SourceFileName"),sourceFileName);

	GetStringFromConfig(ConfigSection(),_L("SuggestedFileName"),suggestedFileName);

	GetStringFromConfig(ConfigSection(),_L("MimeType"),mimeType);

	GetIntFromConfig(ConfigSection(),_L("LeaveResult"),expectedLeave);

	StartApparcServerL();

	__UHEAP_MARK;

	HBufC8 *mime = ConvertDes16toHBufC8LC(mimeType);

	CCafMimeHeader *header = CCafMimeHeader::NewL(mime->Des());

	CleanupStack::PushL(header);

	CSupplier *mySupplier = CSupplier::NewLC();

	mySupplier->SetOutputDirectoryL(outputDirectory);

	// ignore return value, just exercises code for CCover

	mySupplier->IsImportSupported(header->StandardMimeData(EContentType));

	CImportFile *import = NULL;

	TRAPD(leaveResult, import = mySupplier->ImportFileL(*header, suggestedFileName));

	if(leaveResult != expectedLeave)

		{

		SetTestStepResult(EFail);

		}

	if(leaveResult == KErrNone)

		{

		CleanupStack::PushL(import);

		// read the input file and pass it to the CAF

		fs.Connect();

		CleanupClosePushL(fs);

		TInt result = file.Open(fs, sourceFileName, EFileRead | EFileStream | EFileShareAny);

		CleanupClosePushL(file);

		while(result == KErrNone)

			{

			result = file.Read(readBuffer);

			if(readBuffer.Length() == 0)

				break;

			status = KRequestPending;

			import->WriteData(readBuffer,status);

			User::WaitForRequest(status);

			}

		CleanupStack::PopAndDestroy(&file); 

		status = KRequestPending;

		import->WriteDataComplete(status);

		User::WaitForRequest(status);

		TInt n = import->OutputFileCountL();

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

			{

			// get output file name

			TPtrC OutputFileName = import->OutputFileL(i).FileName();

			INFO_PRINTF2(_L("Output File Created: %S"),&OutputFileName);

			// get output file type (content or receipt)

			TOutputType outputType = import->OutputFileL(i).OutputType();

			if(outputType == EReceipt)

				{

				INFO_PRINTF1(_L("Output File is a receipt"));

				}

			else

				{

				INFO_PRINTF1(_L("Output File is content"));

				}

			// get output file mime type

			TPtrC8 OutputMimeType = import->OutputFileL(i).MimeTypeL();

			HBufC *mime = ConvertDes8toHBufC16LC(OutputMimeType );

			INFO_PRINTF2(_L("Output File Mime Type: %S"),mime);

			CleanupStack::PopAndDestroy(mime); 

			}

		CleanupStack::PopAndDestroy(&fs); 

		CleanupStack::PopAndDestroy(import); 

		}

	CleanupStack::PopAndDestroy(mySupplier); 

	CleanupStack::PopAndDestroy(header); 

	CleanupStack::PopAndDestroy(mime); 

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

/* 

 * This step imports a DCF file into CAF 

 *

 */

CCafClientOutputSupplierStep::~CCafClientOutputSupplierStep()

	{

	}

CCafClientOutputSupplierStep::CCafClientOutputSupplierStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFClientOutputSupplierStep);

	}

void CCafClientOutputSupplierStep::CheckContentMimeL(CImportFile* aImport, TDes8& aContentMime, TDesC8& aExpectedContentMime)

	{

	if(!aImport->ContentMimeTypeL(aContentMime))

		{

		//Agent can't determine the content MIME type with available data at the moment

		INFO_PRINTF1(_L("Content MIME Type can't be determined"));

		SetTestStepResult(EFail);

		return;

		}

	//If we reach here, we are expecting a correct Content MIME type 

	HBufC *mime = ConvertDes8toHBufC16LC(aContentMime);

	INFO_PRINTF2(_L("Content MIME Type: %S"), mime);

	CleanupStack::PopAndDestroy(mime);

	if(aContentMime.CompareF(aExpectedContentMime) == 0)

		{

		SetTestStepResult(EPass);

		}

	else

		{

		ERR_PRINTF1(_L("Content MIME Type doesn't match expected"));

		SetTestStepResult(EFail);

		}

	}

TVerdict CCafClientOutputSupplierStep::doTestStepL()

	{

	SetTestStepResult(EInconclusive);

	RFs fs;

	RFile file;

	TBuf8 <128> readBuffer;

	TBuf8 <255> mimetype8;

	TFileName outputFileName;

	RFile outputFile;

	CImportFile *import = NULL;

	// first output file will be a.txt

	_LIT(KOutputFileName, "C:\\something.drm");

	outputFileName.Copy(KOutputFileName);

	INFO_PRINTF1(_L("Supplier Test - Client provides output files"));

	TPtrC outputDirectory, sourceFileName, suggestedFileName, mimeType, expectedContentMime;

	TInt expectedLeave;

	TBool checkContentMime = EFalse;

	TBuf8<KMaxDataTypeLength> contentMimeType;	

	// Get parameters from INI file

	GetStringFromConfig(ConfigSection(),_L("OutputPath"),outputDirectory);

	GetStringFromConfig(ConfigSection(),_L("SourceFileName"),sourceFileName);

	GetStringFromConfig(ConfigSection(),_L("SuggestedFileName"),suggestedFileName);

	GetStringFromConfig(ConfigSection(),_L("MimeType"),mimeType);

	GetIntFromConfig(ConfigSection(),_L("LeaveResult"),expectedLeave);

	GetStringFromConfig(ConfigSection(),_L("ExpectedContentMime"),expectedContentMime);

	GetBoolFromConfig(ConfigSection(),_L("CheckContentMime"),checkContentMime);

	StartApparcServerL();

	__UHEAP_MARK;

	mimetype8.Copy(mimeType);

	// fill in meta data - just the mime type really

	CMetaDataArray *array = CMetaDataArray::NewL();

	CleanupStack::PushL(array);

	_LIT8(KContentType,"content-type");

	array->AddL(KContentType(), mimetype8);

	// create a supplier session

	CSupplier *mySupplier = CSupplier::NewL();

	CleanupStack::PushL(mySupplier);

	// check import is supported, ignore return value, just exercises code for CCover

	mySupplier->IsImportSupported(array->SearchL(KContentType()));

	// create import session

	TRAPD(leaveResult, import = mySupplier->ImportFileL(mimetype8, *array));

	if(leaveResult != expectedLeave)

		{

		SetTestStepResult(EFail);

		}

	if(leaveResult == KErrNone)

		{

		CleanupStack::PushL(import);

		// read the input file and pass it to the CAF

		fs.Connect();

		CleanupClosePushL(fs);

		TInt result = file.Open(fs, sourceFileName, EFileRead | EFileStream | EFileShareAny);

		CleanupClosePushL(file);

		TParsePtrC parse(suggestedFileName);

		TPtrC desiredOutFileName( parse.Name() );

		while(result == KErrNone)

			{

			result = file.Read(readBuffer);

			if(readBuffer.Length() == 0)

				break;

			result = import->WriteData(readBuffer);

			while(result == KErrCANewFileHandleRequired)

				{

				if(checkContentMime)

					{

					//If CheckContentMimeL failed, Client code should assume content MIME type wouldn't

					//be available until after the supply session has finished. The imported data could be

					//output to default location

					//In this test step, data are always output to default location regardless of content MIME

					//type

					TBuf8<KMaxDataTypeLength> expectedContentMime8bit;

					expectedContentMime8bit.Copy(expectedContentMime);

					CheckContentMimeL(import, contentMimeType, expectedContentMime8bit);

					//no more check needed in following iterations

					checkContentMime = EFalse;

					//At this point client should decide where to save the file based on content mime

					}

				const TInt KMaxExtLen = 28;

				TBuf<KMaxExtLen> suggestedExt;

				User::LeaveIfError(import->GetSuggestedOutputFileExtension(suggestedExt));

				outputFileName.Copy(outputDirectory);

				outputFileName.Append(desiredOutFileName);

				outputFileName.Append(suggestedExt);

				// create a new outputfile

				fs.Delete(outputFileName);

				User::LeaveIfError(outputFile.Create(fs,outputFileName, EFileShareAny  | EFileStream | EFileWrite));

				result = import->ContinueWithNewOutputFile(outputFile,outputFileName);

				outputFile.Close();

				}

			User::LeaveIfError(result);

			}

		CleanupStack::PopAndDestroy(&file); 

		result = import->WriteDataComplete();

		while(result == KErrCANewFileHandleRequired)

				{

				TFileName suggestedName;

				User::LeaveIfError(import->GetSuggestedOutputFileName(suggestedName));

				outputFileName.Copy(outputDirectory);

				outputFileName.Append(suggestedName);

				// create a new outputfile

				fs.Delete(outputFileName);

				User::LeaveIfError(outputFile.Create(fs,outputFileName, EFileShareAny  | EFileStream | EFileWrite));

				result = import->ContinueWithNewOutputFile(outputFile,outputFileName);

				outputFile.Close();

				}

		TInt n = import->OutputFileCountL();

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

			{

			// get output file name

			TPtrC OutputFileName = import->OutputFileL(i).FileName();

			INFO_PRINTF2(_L("Output File Created: %S"),&OutputFileName);

			// get output file type (content or receipt)

			TOutputType outputType = import->OutputFileL(i).OutputType();

			if(outputType == EReceipt)

				{

				INFO_PRINTF1(_L("Output File is a receipt"));

				}

			else

				{

				INFO_PRINTF1(_L("Output File is content"));

				}

			// get output file mime type

			TPtrC8 OutputMimeType = import->OutputFileL(i).MimeTypeL();

			HBufC *mime = ConvertDes8toHBufC16LC(OutputMimeType );

			INFO_PRINTF2(_L("Output File Mime Type: %S"),mime);

			CleanupStack::PopAndDestroy(mime); 

			}

		CleanupStack::PopAndDestroy(&fs); 

		CleanupStack::PopAndDestroy(import); 

		}

	CleanupStack::PopAndDestroy(mySupplier); 

	CleanupStack::PopAndDestroy(array); 

	__UHEAP_MARKEND;

	if (TestStepResult() != EFail)

		{

		SetTestStepResult(EPass);

		}

	return TestStepResult();

	}

/* 

 * This step tests the ExternalizeL() and InternalizeL() functions for

 * CCafMimeHeader

 */

CCAFSupplierSerializeStep::~CCAFSupplierSerializeStep()

	{

	}

CCAFSupplierSerializeStep::CCAFSupplierSerializeStep(CCAFServer& aParent) : iParent(aParent)

	{

	SetTestStepName(KCAFSupplierSerializeStep);

	}

TVerdict CCAFSupplierSerializeStep::doTestStepL()

	{	

	_LIT8(KDrmMime,"application/testagent.drm");

	_LIT8(KBinaryEncoding,"Binary");

	_LIT8(KOmaRightsPending, "X-Oma-Drm-Separate-Delivery");

	_LIT8(KOmaRightsPendingValue, "12");

	SetTestStepResult(EInconclusive); // Default result to EInconclusive

	__UHEAP_MARK;

	// create a CafMimeHeader with "content type:" application/testagent.drm

	CCafMimeHeader *header = CCafMimeHeader::NewL(KDrmMime());

	CleanupStack::PushL(header);

	// Add some information to the header

	header->SetStandardMimeDataL(EContentTransferEncoding, KBinaryEncoding());