/**
* Copyright (c) 1996-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:
* File Name:		f32test/bench/t_fat_perf.h
* Include file for t_fat_perf.cpp (PREQ 1885).
* 
*
*/



//Include Files
#include <f32file.h>
#include <e32test.h>
#include <hal.h>
#include "t_server.h"
#include "fat_utils.h"
#include "f32_test_utils.h" 

using namespace F32_Test_Utils;
using namespace Fat_Test_Utils;

extern TInt gTestCaseNo;

extern TFileName 	gPath;
extern TFileName 	gFileNameBase;
extern TInt 		gFileNo;
extern TInt		    gTestCase;
extern TInt			gCacheClear;
extern TInt         gZeroPadFileNumberForFixedLengthFileNames;

//////////////////////////////////////////////////////////////////////////////
// Interfaces

// File Operation Modes
enum TFileOperationMode
	{
	EFATPerfFileOpen,
	EFATPerfFileCreate,
	EFATPerfFileReplace,
	EFATPerfFileDelete,
	EFATPerfFileWrite,
	EFATPerfFileRead,
	};

// File Creation Options
enum TNamingConOrRan
	{
	EConsecutive,
	ERandom,
	};

// Standards
enum TNamingUniOrAsc
	{
	EAscii,
	EUnicode,
	};

// Test function names
enum TTestFunction
	{
	EFATPerfSetup,
	EFATPerfCreate,
	EFATPerfOpen,
	EFATPerfDelete,
	EFATPerfRead,
	EFATPerfWrite,
	EFATPerfDirCacheInfo,
	};
	
// For DirCache info printing 
// These enum values are based on enum TControlIO defined in \f32\sfat\common_constants.h
enum TDirCacheControlIOMap
	{
	ETestDumpFATDirCache = 15,	///<15
	ETestFATDirCacheInfo = 16,	///<16
	};

// File Naming schemes
class TNamingSchemeParam
	{
public:
    TNamingSchemeParam();
    
public:
	TNamingConOrRan	iConOrRan;
	TNamingUniOrAsc	iUniOrAsc;
	TBool iZeroPadFileNumber; // Only applies to consecutive file name generation
	TFileName 	iFileNameBase;
	TUint	iMaxFileNameLength;	// Applies only to random name generation
	TUint	iMinStringLength;
	};

class CMeasureAndLogUnit;

// File Operation Parameters
struct TFileOpUnitParam
	{
	TFileName 	iDirName;
	TNamingSchemeParam iNamingSchemeParam;
	TFileOperationMode	iFileOpMode;
	CMeasureAndLogUnit* iMLUnitPtr;
	};

// Directory Unit Parameters
struct TDirUnitParam
	{
	TUint		iPriority;
	TFileName	iDirName;
	TUint		iRuns;
	TUint		iFilesPerRun;
	TUint		iSampleInterval;
	TNamingSchemeParam		iNamingScheme;
	TFileOperationMode		iFileOpMode;
	};

struct	TMLUnitParam
	{
	TInt	iID;
	};

struct TMLParam
	{
	TFileName	iDirName;
	TFileName	iFileName;
	TNamingSchemeParam iNamingScheme;
	TUint	iCurFileNo;
	TFileOperationMode	iFileOpMode;
	};

/////////////////////////////////////////////////////////////////////////////////////////////
// Module definition


// Measurement and Log Unit
class CMeasureAndLogUnit : CBase
	{
public:
	static CMeasureAndLogUnit* NewLC(const TMLUnitParam& aParam);
	static CMeasureAndLogUnit* NewL(const TMLUnitParam& aParam);
	~CMeasureAndLogUnit();
	TInt	MeasureStart();
	TInt	MeasureEnd();
	TInt	Log(const TFileName& aDirName, const TFileName& aFileName, TUint aCurrentFileNo, TUint aCurrentFilePos);
private:
	CMeasureAndLogUnit();
	void ConstructL(const TMLUnitParam& aParam);
	TInt	DoMeasureStart();
	TInt	DoMeasureEnd();
	TInt	DoLog(const TFileName& aFileName, TUint aCurrentFileNo, TUint aCurrentFilePos);
	
private:
	TInt	iID;
	TUint32	iStartStatus;
	TUint32	iEndStatus;
	TInt	iFreq;
	TReal	iScale;		
	TUint	iLogItemNo;
	};

// File Operation Unit
class CFileOperationUnit : CBase
	{
public:
	static CFileOperationUnit* NewLC(const TFileOpUnitParam& aParam);
	static CFileOperationUnit* NewL(const TFileOpUnitParam& aParam);
	~CFileOperationUnit();
	
	TInt 	Run(const TFileName& aDirName, const TFileName& aFileName, TBool aIsTakingMeasurement, TUint aCurFileNo, TUint aCurFilePos);
	void	SetMLUnit(CMeasureAndLogUnit* aMLUnit);

private:
	CFileOperationUnit();	
	void ConstructL(const TFileOpUnitParam& aParam);

private:
	TFileName 	iDirName;
	TNamingSchemeParam iNamingSchemeParam;
	TFileOperationMode	iFileOpMode;
	CMeasureAndLogUnit* iMLUnitPtr;
	RFs					iRFs;
	TBool				iDirCreated;
	};


class CDirUnit : public CBase
	{
public:
	static CDirUnit* NewLC(const TDirUnitParam& aParam, const TChar aDriveChar);
	static CDirUnit* NewL(const TDirUnitParam& aParam, const TChar aDriveChar);
	~CDirUnit();
	TInt Run(const TInt aCurPriority);
	void SetMLUnit(CMeasureAndLogUnit* aMLUnit);
	TInt Priority();
	const TFileName& Name();

private:
	CDirUnit();
	void ConstructL(const TDirUnitParam& aParam, const TChar aDriveChar);

	TInt 	GenerateFileName(TFileName& aFileName); // uses iNameGen
	TBool 	CheckMeasurementTaking();		     	// uses currentFileNo, 
												    // totalFileNo, 
												    // samplingInterval
	TInt 	DoFileOperation();
	TFileName GenerateRandomString(const TUint aMinStringLength, const TUint aMaxStringLength, const TNamingUniOrAsc aUniOrAsc);
	TBool FileNameIsUnique(const TFileName& aFileName);
private:
	TInt					iPriority;
	TFileName				iDirName;
	TUint					iRuns;
	TUint					iCurrentRunNo;
	TUint					iFilesPerRun;
	TUint					iCurrentFileNo;
	TUint					iTotalFileNo;
	TUint					iSampleInterval;
	
	TUint                   iNumDigitsInTotalFileNo;    // The number of digits iTotalFileNo has.
                                                        // Used to zero pad the file number if iZeroPadFileNumberForFixedWidthFileNames is ETrue
	
	TNamingConOrRan	iConOrRan;                 // Consecutive or random
	TNamingUniOrAsc	iUniOrAsc;                 // ASCII or Unicode
	TBool iZeroPadFileNumberForFixedLengthFileNames;
	TFileName 			iFileNameBase;
	TUint				iMaxFileNameLength;   // Applies only to random name generation
	TUint				iMinStringLength;     // Applies only to random name generation
	
	CFileOperationUnit* 	iFileOpUnit;
	CMeasureAndLogUnit*	iMLUnitPtr;
	
	};

//Execution Unit
class CExecutionUnit : public CBase
	{
public:
	static CExecutionUnit* NewLC(CMeasureAndLogUnit* aMLUnit, const TChar aDriveChar);
	static CExecutionUnit* NewL(CMeasureAndLogUnit* aMLUnit, const TChar aDriveChar);

	~CExecutionUnit();

	TInt 	AddDirUnitL(const TDirUnitParam& aParam);
	TInt	RecalculateCurrentPrioirty();
	TInt 	Run();

	///For Debug
	TUint ForDebug_AddrOfDirUnit(TUint aDirUnitIter);
	TUint ForDebug_AddrOfDirUnitArray();

private:
	CExecutionUnit();
	void ConstructL(CMeasureAndLogUnit* aMLUnit, const TChar aDriveChar);

private:
	// Array of CDirUnit
	RPointerArray<CDirUnit>	iDirUnitArray;
	
	// Logging Unit
	CMeasureAndLogUnit*	iMLUnitPtr;	// no ownership
	
	// Current priority
	TInt 	iCurPriority;
	
	TChar	iDriveChar;
	
	}; 
	
/*-- EOF--*/