// Copyright (c) 2008-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:
// f32test\cfileman\t_cfileman_aux.cpp
// 
//

#include "t_cfileman_aux.h"

CFileMan* gFileMan = NULL;
RPointerArray<RFile>* gFileHandles = NULL;
TBool gAsynch = EFalse;
TRequestStatus gStat;
TBool testingInvalidPathLengths;

void InitialiseL()
	{
	gFileMan=CFileMan::NewL(TheFs);
	}

void RmDir(const TDesC& aDirName)
	{
	TFileName filename_dir = aDirName;
	TInt r = 0;
	r = TheFs.SetAtt(filename_dir, 0, KEntryAttReadOnly);
	r=gFileMan->RmDir(filename_dir);
	test(r==KErrNone || r==KErrNotFound || r==KErrPathNotFound);
	}

// Cleanup test variables
void Cleanup()
	{
	delete gFileMan;
	}

//Test that the contents of two directories are identical
TBool CompareL(const TDesC& aDir1,const TDesC& aDir2)
	{
	TBool rel = ETrue;
	CDirScan* scanDir1=CDirScan::NewL(TheFs);
	scanDir1->SetScanDataL(aDir1,KEntryAttMaskSupported,ESortByName);
	CDirScan* scanDir2=CDirScan::NewL(TheFs);
	scanDir2->SetScanDataL(aDir2,KEntryAttMaskSupported,ESortByName);

	FOREVER
		{
		CDir* entryList1;
		CDir* entryList2;

		scanDir1->NextL(entryList1);
		scanDir2->NextL(entryList2);

		if (entryList1==NULL || entryList2==NULL)
			{
			if (!(entryList1==NULL && entryList2==NULL))
				{
				delete entryList1, 
				delete entryList2, 
				delete scanDir1, 
				delete scanDir2;
				return(EFalse);
				}
			break;
			}

		TFileName abbPath1=scanDir1->AbbreviatedPath();
		TFileName abbPath2=scanDir2->AbbreviatedPath();
		if (!(abbPath1==abbPath2))
			{
			delete entryList1, 
			delete entryList2, 
			delete scanDir1, 
			delete scanDir2;
			return(EFalse);
			}

		TInt count1=entryList1->Count();
		TInt count2=entryList2->Count();
		if (!(count1==count2))
			{
			delete entryList1, 
			delete entryList2, 
			delete scanDir1, 
			delete scanDir2;
			return(EFalse);
			}

		while(count1--)
			{
			TEntry entry1=(*entryList1)[count1];
			TEntry entry2=(*entryList2)[count1];
			if (!(entry1.iName==entry2.iName))
				{
				delete entryList1, 
				delete entryList2, 
				delete scanDir1, 
				delete scanDir2;
				return(EFalse);
				}
			if (!(entry1.iAtt==entry2.iAtt))
				{
				delete entryList1, 
				delete entryList2, 
				delete scanDir1, 
				delete scanDir2;
				return(EFalse);
				}

			}

		delete entryList1;
		delete entryList2;
		}

	delete scanDir1;
	delete scanDir2;
	
	return rel;
	}

/**
    Parsing Dir Data Block
    @param  aDataBlock		data block in TInt[] for parsing	
    @param  aDirDataArray	returning dir data array after parsing

    @panic 					if data setup error

*/
void ParsingDirDataBlock(const TInt aDataBlock[], RArray<TInt>& aDirDataArray)
	{
	TInt err = KErrNone;
	aDirDataArray.Reset();

	if (aDataBlock[0] == EOB)
		{
		return;
		}

	TInt i = 1;
	FOREVER
		{
		TInt lastItem = aDataBlock[i-1];
		TInt currentItem = aDataBlock[i];
		
		// check currentItem
		if (currentItem == EOB)
			{
			if (lastItem == CON || lastItem > LAST)
			//check last
				{
				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
				test(EFalse);
				}
			else
			// passed, insert last, break
				{
				err = aDirDataArray.InsertInOrder(lastItem);
				if (err != KErrNone && err != KErrAlreadyExists)
					{
					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
					test(EFalse);
					}
				break;
				}
			}
		
		else if (currentItem == CON)
		// if current == CON
			{
			if (lastItem == CON || lastItem >= LAST)
			// check last item
				{
				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
				test(EFalse);
				}
			else // last < LAST, last != CON
				{
				// check next item
				TInt nextItem = aDataBlock[i+1];
				if (nextItem <= 0 || nextItem > LAST || lastItem >= nextItem)
					{
					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
					test(EFalse);
					}
				else
					{
					// all valid
					for (TInt j = lastItem; j < nextItem; j++)
						{
						err = aDirDataArray.InsertInOrder(j);
						if (err != KErrNone && err != KErrAlreadyExists)
							{
							test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
							test(EFalse);
							}
						}
					}
				}
			i++;
			}

		else if (0 <= currentItem && currentItem <= LAST)
		// if current == normal item
			{
			if (lastItem == CON)
				{
				i++;
				continue;
				}
			else if (lastItem >= LAST)
			// check last item
				{
				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
				test(EFalse);
				}
			else
			// passed, insert last
				{
				err = aDirDataArray.InsertInOrder(lastItem);
				if (err != KErrNone && err != KErrAlreadyExists)
					{
					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
					test(EFalse);
					}
				}
			i++;
			}
		
		else	// invalid input
			{
			test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);
			test(EFalse);
			}
		}
	}

	
/**
	Setup attribs:
	@param  filenamedir   		root path of dir data or a file data
	@param  mode			    value of an mode to be set(Normal/Open/Shared..)
*/
void OpenFile(TDesC& aFile, TFileMode aFileMode)
	{
	RFile* file = new (ELeave) RFile;
	gFileHandles->Append(file);
	TInt ret = 0;
	ret = file->Open(TheFs, aFile, aFileMode);
	test(ret==KErrNone);
	}
	

/**
    Setup dir structure for testing and verifying functional results
    @param	datastr			data structure to setup directory
    @param  iOperation   	Operation to be performed 
    @param  SrcDrive		Source drive
    @param	Targetdrive		Target drive input
    @panic					if data structure definition is incorrect
*/
void SetupDirFiles(const TDesC& aPath, const TDirSetupFiles& aDirFiles)
	{
	TFileName path = aPath;
	if (path.Length() == 0)
		{
		test.Printf(_L("ERROR<SetupDirFiles()>: Zero length src path!\n"));
		test(EFalse);
		}
	
	RmDir(path);
	MakeDir(path);

	RArray<TInt> addBlockDataArray;
	RArray<TInt> deductBlockDataArray;
	
	ParsingDirDataBlock(aDirFiles.iAddingBlock, addBlockDataArray);
	ParsingDirDataBlock(aDirFiles.iDeductBlock, deductBlockDataArray);
	
	if (addBlockDataArray.Count() == 0)
	// empty dir setup
		{
		return;
		}
	else
		{
		for (TInt i = 0; i < deductBlockDataArray.Count(); ++i)
			{
			TInt idxToDelete = addBlockDataArray.FindInOrder(deductBlockDataArray[i]);
			if (idxToDelete >= 0)
				{
				addBlockDataArray.Remove(idxToDelete);
				}
			else if (idxToDelete == KErrNotFound)
				{
				continue;
				}
			else
				{
				test.Printf(_L("ERROR<<SetupDir>>: wrong dir data setup! err=%d\n"), idxToDelete);
				test(EFalse);
				}
			}
		}

	if (addBlockDataArray.Count() > 0)
		{
		for (TInt i = 0; i < addBlockDataArray.Count(); ++i)
			{
			TInt idx = addBlockDataArray[i];
			path = aPath;
			path += gDirPatterns[idx];
			if (path[path.Length() - 1] == '\\')
				{
				MakeDir(path);
				}
			else
				{
				MakeFile(path, _L8("blahblah"));

				}
			}
		}

	addBlockDataArray.Reset();
	deductBlockDataArray.Reset();
	}

/**
    Print out all items in aPath
    @param  aPath 		root path for scanning

    @panic				SetScanData error
*/
void PrintDir(const TDesC& aPath, const TChar& aDrv)
	{
	TFileName fn;
	if (aPath.Length() == 0)
		{
		return;
		}
	else
		{
		fn = aPath;
		fn[0] = (TUint16)aDrv;
		test.Printf(_L("==============================\n"));
		test.Printf(_L("<<PrintDir>>: root = \"%S\"\n"), &fn);
		}

	CDirScan* scan = CDirScan::NewL(TheFs);
	TUint entryAttMask = KEntryAttMaskSupported;
	TUint entrySortMask = EDirsLast|EAscending;
	CDirScan::TScanDirection scanDirection = CDirScan::EScanDownTree;


	TRAPD(err, scan->SetScanDataL(fn, entryAttMask, entrySortMask, scanDirection));
	test(err == KErrNone);

	CDir* dir = NULL;
	TInt i = 0;
	TBool temp_val = ETrue;
	while (temp_val)
		{
		scan->NextL(dir);
		if (dir != NULL)
			{
			for (TInt j = 0; j < dir->Count(); ++j)
				{
				TFileName item(fn.Left(aPath.Length() - 1));
				item.Append(scan->AbbreviatedPath());
				TEntry dummy = (*dir)[j];
				item.Append(dummy.iName);
				if (dummy.iAtt & KEntryAttDir)
					{
					item.Append('\\');
					}
				test.Printf(_L("<<PrintDir>>: item %d: \"%S\"\n"), i, &item);
				++i;
				}
			delete dir;
			dir = NULL;
			}
		else
			{
			break;
			}
		}
	delete scan;
	}