/*
* 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());
	header->AddNonStandardMimeL(KOmaRightsPending(), KOmaRightsPendingValue());

	// Create a buffer stream
	CBufFlat* buf = CBufFlat::NewL(50);
	CleanupStack::PushL(buf);
	RBufWriteStream stream(*buf);
	CleanupClosePushL(stream);

	// call the stream function
	stream << *header;
	CleanupStack::PopAndDestroy(&stream);

	// Now, create an HBufC8 from the stream buf's length, and copy 
	// the stream buffer into this descriptor
	HBufC8* des = HBufC8::NewL(buf->Size());
	TPtr8 ptr(des->Des());
	buf->Read(0, ptr, buf->Size());

	// destroy the buffer
	CleanupStack::PopAndDestroy(buf);
	CleanupStack::PushL(des);

	// Now, stream a new CCafMimeHeader from the descriptor
	CCafMimeHeader* newHeader = CCafMimeHeader::NewL(KNullDesC8());
	CleanupStack::PushL(newHeader);
	RDesReadStream readstream(*des);
	CleanupClosePushL(readstream);
	readstream >> *newHeader;
	CleanupStack::PopAndDestroy(&readstream);

	// Now check that the new bitset equals the old one
	TInt result = newHeader->StandardMimeData(EContentType).Compare(KDrmMime());
	if (result != 0)
		{
		INFO_PRINTF1(_L("Content type was not copied properly during seriaization"));
		SetTestStepResult(EFail);
		}
	result = newHeader->StandardMimeData(EContentTransferEncoding).Compare(KBinaryEncoding());
	if (result != 0)
		{
		INFO_PRINTF1(_L("Content Length was not copied properly during seriaization"));
		SetTestStepResult(EFail);
		}
	
	if (newHeader->NonStandardMimeCount() != 1)
		{
		INFO_PRINTF1(_L("Non standard field array not copied properly during seriaization"));
		SetTestStepResult(EFail);
		}

	result = newHeader->NonStandardMimeField(0).Compare(KOmaRightsPending());
	if (result != 0)
		{
		INFO_PRINTF1(_L("Non standard field not copied properly during seriaization"));
		SetTestStepResult(EFail);
		}

	result = newHeader->NonStandardMimeData(0).Compare(KOmaRightsPendingValue());
	if (result != 0)
		{
		INFO_PRINTF1(_L("Non standard field data was not copied properly during seriaization"));
		SetTestStepResult(EFail);
		}

	CleanupStack::PopAndDestroy(3, header);

	__UHEAP_MARKEND;
	
	if (TestStepResult() != EFail)
		{
		SetTestStepResult(EPass);
		}

	return TestStepResult();
	}

#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY

/* 
 * Check that applications can retrieve the HTTP request headers
 */
CCAFHTTPRequestHeadersStep::~CCAFHTTPRequestHeadersStep()
	{
	}

CCAFHTTPRequestHeadersStep::CCAFHTTPRequestHeadersStep(CCAFServer& aParent) : iParent(aParent)
	{
	SetTestStepName(KCAFHTTPRequestHeadersStep);
	}


void CCAFHTTPRequestHeadersStep::MHFRunL(RHTTPTransaction, const THTTPEvent&)
	{
	
	}
	
TInt CCAFHTTPRequestHeadersStep::MHFRunError(TInt, RHTTPTransaction, const THTTPEvent&)
	{
	return 0;
	}


TVerdict CCAFHTTPRequestHeadersStep::doTestStepL()
	{	
	_LIT8(Kuri, "http://www.symbian.com/");
	TPtrC8 acceptHeader;
	TInt i = 0;
	TInt result = 0;
	
	SetTestStepResult(EInconclusive); // Default result to EInconclusive
	THTTPHdrVal aValue;
	
	__UHEAP_MARK;

	CSupplier* supplier = CSupplier::NewLC();
	
	// Create an HTTP session 
	RHTTPSession session;
	session.OpenL();
	RStringPool pool = session.StringPool();
	
	
	// Convert the URI string into a TUri8
	TUriParser8 parser;
	parser.Parse(Kuri());
	
	// create an HTTP transaction
	RHTTPTransaction transaction = session.OpenTransactionL(parser, *this, pool.StringF(HTTP::EGET,RHTTPSession::GetTable()));
	RHTTPHeaders hdr = transaction.Request().GetHeaderCollection();

	// Get the request headers from the agent
	supplier->PrepareHTTPRequestHeaders(pool, hdr);
	
	TInt fieldParts = hdr.FieldPartsL(pool.StringF(HTTP::EAccept, RHTTPSession::GetTable()));
	if(fieldParts == 3)
		{
		for(i = 0; i < fieldParts; i++)
			{
			// loop over all accept headers make sure we find the three we expect
			User::LeaveIfError(hdr.GetField(pool.StringF(HTTP::EAccept, RHTTPSession::GetTable()), i, aValue));
	
			RStringF header = (RStringF) aValue;
			acceptHeader.Set(header.DesC()); 
		
			// Reference Test Agent - content MIME type
			if(acceptHeader.Compare(_L8("application/x-rta.drm.content")) == 0)
				{
				result |= 1;
				}
			// Reference Test Agent - content + rights MIME type
			else if(acceptHeader.Compare(_L8("application/x-rta.drm.contentrights")) == 0)
				{
				result |= 2;
				}
			// Test Agent - MIME type
			else if(acceptHeader.Compare(_L8("APPLICATION/TESTAGENT.DRM")) == 0)
				{
				result |= 4;
				}
			}
		if(result != 7)
			{
			// not all three headers were found
			INFO_PRINTF1(_L("Not all expected HTTP Accept headers were present"));
			SetTestStepResult(EFail);		
			}
		}
	else
		{
		// We were expecting three accept headers to be set
		// two from the Reference Test Agent and one from Test Agent
		INFO_PRINTF2(_L("ERROR: Only %d HTTP Accept headers were returned, expected 3"), fieldParts);
		SetTestStepResult(EFail);	
		}
		
	transaction.Close();
	session.Close();
	CleanupStack::PopAndDestroy(supplier);
	__UHEAP_MARKEND;
	
	if (TestStepResult() != EFail)
		{
		SetTestStepResult(EPass);
		}

	return TestStepResult();
	}

#endif