// Copyright (c) 1999-2009 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:

//

// System includes

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

// Globals

static RFs								TheFs;

static RTest							TheTest(_L("TLOADER - Test help file loading schema"));

static CTrapCleanup*					TheTrapCleanup;

// Constants

// Literal constants

_LIT(KHlpFileSpec,			"*.h*");

_LIT(KHlpFileSearchPath,	"\\Resource\\Help\\");

// Classes referenced

class CHlpFileEntry;

// Typedefs

typedef CArrayPtrFlat<CHlpFileEntry> CHlpFileList;

//

// ----> CHlpFileEntry (header)

//

class CHlpFileEntry : public CBase

	{

public:

	enum THelpFileType

		{

		EPrimary,

		ESecondary,

		EGeneral,			

		EInpropperLocale,

		EDiscarded

		};

public:

	static CHlpFileEntry* NewLC(TDriveUnit aDrive, const TDesC& aFile, TLanguage aLanguage);

	inline TDriveUnit Drive() const { return iDrive; }

	inline const TDesC& FileName() const { return iFile; }

	inline const TDesC& Name() const { return iName; }

	inline THelpFileType Type() const { return iType; }

	inline void SetType(THelpFileType aType) { iType = aType; }

	inline TLanguage HelpFileLocale() const { return iHelpFileLocale; }

	void GetFullNameAndPath(TDes& aName) const;

private:

	CHlpFileEntry(TDriveUnit aDrive, const TDesC& aFile) : iHelpFileLocale(ELangOther), iFile(aFile), iDrive(aDrive) {}

	void ConstructL(TLanguage aLanguage);

	void MakeLocaleSpecificExtension(TDes& aNameToAppendTo, TLanguage aLanguage) const;

	TLanguage NextLanguage(TLanguage aLanguage) const;

private:

	TLanguage iHelpFileLocale; // Only valid when the type is not EGeneral

	TName iName;

	TName iFile;

	TDriveUnit iDrive;

	THelpFileType iType;

	};

//

// ----> CHlpFileEntry (source)

//

void CHlpFileEntry::ConstructL(TLanguage aLanguage)

	{

	_LIT(KDefaultHelpFileExtension, ".hlp");

	// Decide what type of file this is....

	TFileName file;

	TChar driveLetter;

	User::LeaveIfError(RFs::DriveToChar(iDrive, driveLetter));

	file.Append(driveLetter);

	file.Append(':');

	file.Append(KHlpFileSearchPath);

	file.Append(iFile);

	TParsePtrC parser(file);

	if	(!parser.ExtPresent())

		User::Leave(KErrCorrupt);

	iName.Copy(parser.Name());

	TPtrC extension(parser.Ext());

	if	(extension.CompareF(KDefaultHelpFileExtension) == 0)

		iType = EGeneral;

	else

		{

		TFileName idealHelpFileName(parser.DriveAndPath());

		idealHelpFileName.Append(parser.Name());

		MakeLocaleSpecificExtension(idealHelpFileName, aLanguage);

		if	(idealHelpFileName.CompareF(file) == 0)

			{

			// This is a primary match

			iType = EPrimary;

			iHelpFileLocale = aLanguage;

			}

		else

			{

			// Is it a secondary match? If it isn't then it should be discarded....

			idealHelpFileName = parser.DriveAndPath();

			idealHelpFileName.Append(parser.Name());

			// Get the nearest secondary language

			aLanguage = NextLanguage(aLanguage);

			MakeLocaleSpecificExtension(idealHelpFileName, aLanguage);

			if	(idealHelpFileName.CompareF(file) == 0)

				{

				iHelpFileLocale = aLanguage;

				iType = ESecondary;

				}

			else

				{

				TLex lexer(extension);

				// Skip the leading .H

				lexer.Inc(2);

				// Lex the value, but silently ignore errors

				TUint localeAsUnsignedInt = ELangOther;

				lexer.Val(localeAsUnsignedInt);

				iHelpFileLocale = STATIC_CAST(TLanguage, localeAsUnsignedInt);

				iType = EInpropperLocale;

				}

			}

		}

	}

TLanguage CHlpFileEntry::NextLanguage(TLanguage aLanguage) const

	{

	switch(aLanguage)

		{

	case ELangSwissFrench:

		return ELangFrench;

	case ELangSwissGerman:

		return ELangGerman;

	case ELangBelgianFlemish:

		return ELangDutch;

	case ELangBelgianFrench:

		return ELangFrench;

	default:

		return ELangEnglish;

		}

	}

CHlpFileEntry* CHlpFileEntry::NewLC(TDriveUnit aDrive, const TDesC& aFile, TLanguage aLanguage)

	{

	CHlpFileEntry* self = new(ELeave) CHlpFileEntry(aDrive, aFile);

	CleanupStack::PushL(self);

	self->ConstructL(aLanguage);

	return self;

	}

//

//

//

void CHlpFileEntry::GetFullNameAndPath(TDes& aName) const

	{

	TChar driveLetter = '?';

	RFs::DriveToChar(Drive(), driveLetter);

	aName.Zero();

	aName.Append(driveLetter);

	aName.Append(':');

	aName.Append(KHlpFileSearchPath);

	aName.Append(FileName());

	}

void CHlpFileEntry::MakeLocaleSpecificExtension(TDes& aNameToAppendTo, TLanguage aLanguage) const

	{

	_LIT(KLocaleExtensionFormat, ".H%02d");

	aNameToAppendTo.AppendFormat(KLocaleExtensionFormat, aLanguage);

	}

static void PrintEntryL(const TDesC& aPrompt, const CHlpFileEntry& aEntry, TInt aNumber = -1)

	{

	TFileName pFileName(aEntry.FileName());

	TChar driveLetter = '?';

	RFs::DriveToChar(aEntry.Drive(), driveLetter);

	//HBufC* buf = HBufC::NewLC(aPrompt.Length() + pFileName.Length() + KHlpFileSearchPath().Length() + 40);

	//TDes pBuf(buf->Des());

	TBuf<256> pBuf;		//Tempory fix to allow this to work in Code Warrior builds.

	if	(aNumber >= KErrNone)

		pBuf.Format(_L("\n%S %d: %c:%S%S\n"), &aPrompt, aNumber, static_cast<TUint>(driveLetter), &KHlpFileSearchPath(), &pFileName);

	else

		pBuf.Format(_L("\n%S: %c:%S%S\n"), &aPrompt, static_cast<TUint>(driveLetter), &KHlpFileSearchPath(), &pFileName);

	TheTest.Printf(pBuf);

	//CleanupStack::PopAndDestroy();

	}

// Defines

#define __PRINT_FILE(aPrompt, aEntry)				(PrintEntryL(aPrompt, aEntry))

#define __PRINT_FILE_NO(aPrompt, aEntry, aNumber)	(PrintEntryL(aPrompt, aEntry, aNumber))

static CHlpFileList* BuildListForDriveLC(TDriveUnit aDrive, RFs& aFsSession)

//

//	Generate a list of help files for the specified drive

//

	{

	CHlpFileList* list = new(ELeave) CHlpFileList(5);

	CleanupStack::PushL(list);

	// Generate the folder spec to search in

	TFileName searchSpec;

	TChar driveLetter;

	User::LeaveIfError(RFs::DriveToChar(aDrive, driveLetter));

	searchSpec.Append(driveLetter);

	searchSpec.Append(':');

	searchSpec.Append(KHlpFileSearchPath);

	searchSpec.Append(KHlpFileSpec);

	CDir* dirList;

	TLanguage language(User::Language());

	TFindFile finder(aFsSession);

	TInt ret = finder.FindWildByPath(searchSpec, NULL, dirList);

	if	(ret < KErrNone)

		{

		if	(ret == KErrNotFound)

			return list;

		else

			User::Leave(ret);

		}

	CleanupStack::PushL(dirList);

	// Add files to help file list

	TInt count = dirList->Count();

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

		{

		CHlpFileEntry* entry = CHlpFileEntry::NewLC(aDrive, (*dirList)[i].iName, language);

		__PRINT_FILE_NO(_L("Found entry during dir scan"), *entry, i);

		// At this point we now check to see if there is already a file with the same name

		// but a different extension already present in the array. If there is already an

		// entry with a lower 'rating' (e.g. ESecondary) than 'entry' we remove the old one

		// and add the new, otherwise, we just ignore the new entry as it's not of sufficient

		// 'quality.'

		TBool foundMatch = EFalse;

		TInt existingEntryCount = list->Count();

		for(TInt j=existingEntryCount-1; j>=0; j--)

			{

			CHlpFileEntry* existingEntry = list->At(j);

			// Is the file already present in the array?

			if	(existingEntry->Name().CompareF(entry->Name()) == 0)

				{

				foundMatch = ETrue;

				__PRINT_FILE(_L("Entry name duplicate"), *entry);

				// Names are the same but extensions differ in some way...

				if	(entry->Type() < existingEntry->Type())

					{

					__PRINT_FILE(_L("New entry is better than the existing entry with the same name.\n Replacing existing entry with:"), *entry);

					// The new entry is better than the existing one, so delete the

					// existing entry and append the new one

					list->Delete(j);

					delete existingEntry;

					list->AppendL(entry);

					break;

					}

				else

					{

					// The entry is of lower 'quality' than the existing entries

					// so we destroy it

					__PRINT_FILE(_L("Discarding low quality entry"), *entry);

					CleanupStack::PopAndDestroy(); // entry

					break;

					}

				}

			}

		// If the file was not present in the existing array then we're free to

		// add it to the array. Otherwise, we assume that it's been deleted or added

		// as appropriate by the looping code above.

		if	(!foundMatch)

			{

			list->AppendL(entry);

			CleanupStack::Pop(); // entry

			}

		}

	CleanupStack::PopAndDestroy(); // dirList

	return list;

	}

static TBool DiskPresent(TInt aDrive)

	{

	TDriveList list;

	if	(TheFs.DriveList(list) < KErrNone)

		return EFalse;

	TDriveInfo info;

	TInt error = TheFs.Drive(info, aDrive);

	if	(error < KErrNone)

		return EFalse;

	return (list[aDrive] && info.iType != EMediaNotPresent);

	}

static void TestL()

	{

	CHlpFileList* masterList = new(ELeave) CHlpFileList(5);

	CleanupStack::PushL(masterList);

	TInt i = EDriveY;

	FOREVER

		{

		// Make sure we go from Y -> C, then do Z last

		if	(i < EDriveC)

			i = EDriveZ;

		if	(DiskPresent(i))

			{

			{

			TChar driveLetter = '?';

			RFs::DriveToChar(i, driveLetter);

			TheTest.Printf(_L("\n\nDisk %c: is installed..."), static_cast<TUint>(driveLetter));

			}

			// This generates a list for a specific directory on the specified drive.

			CHlpFileList* list = BuildListForDriveLC(TDriveUnit(i), TheFs);

			// We now compare this list with our 'master' list to check for duplicates,

			// better matches, etc.

			TInt masterCount = masterList->Count();

			for(TInt j=masterCount-1; j>=0; j--)

				{

				CHlpFileEntry* entry = masterList->At(j);

				// This bit checks to see if an entry in the master list 

				// collides with an entry in the list we have just generated...

				//TBool foundCollision = EFalse;

				TInt newListCount = list->Count();

				for(TInt k=newListCount-1; k>=0; k--)

					{

					CHlpFileEntry* newEntry = list->At(k);

					__PRINT_FILE_NO(_L("Performing drive resolution on entry"), *newEntry, k);

					if	(entry->Name().CompareF(newEntry->Name()) == 0)

						{

						// Names are the same, so compare priorities...

						if	(newEntry->Type() == entry->Type())

							{

							// A file with the same name AND extension is already present in the array,

							// but are the UID's the same? If they are NOT, then the file

							// should be treated as a different help file to that of the 

							// existing array entry.

							TFileName file;

							TEntry existingTEntry;

							entry->GetFullNameAndPath(file);

							User::LeaveIfError(TheFs.Entry(file, existingTEntry));

							TEntry newTEntry;

							newEntry->GetFullNameAndPath(file);

							User::LeaveIfError(TheFs.Entry(file, newTEntry));

							if	(existingTEntry.MostDerivedUid() == newTEntry.MostDerivedUid())

								{

								// The uids and names of the files are the same. If the extensions are also the same

								// then we load the file on the drive tending to C:. However, if the extensions differ

								// we load the file with the extension tending to 01, i.e. UK English.

								if	(entry->FileName().CompareF(newEntry->FileName()) == 0)

									{

									// Name, uid and extensions are the same, therefore load the file on the drive

									// nearest C:. We do this by setting the priority of the existing entry to

									// EDsicarded so that it will force the next 'if' statement to fire, and hence

									// the existing entry will be replaced by the new one.

									entry->SetType(CHlpFileEntry::EDiscarded);

									__PRINT_FILE(_L("Uid, name, extension match. Saving entry tending to C: which is"), *newEntry);

									}

								else

									{

									// Name and uid the same, extensions different therefore load the file with

									// extension nearest to 01. If the new entry is nearer 01, then we set the

									// existing entry to discarded and therefore it will be removed at the next

									// 'if' statement.

									if	(entry->HelpFileLocale() > newEntry->HelpFileLocale())

										{

										entry->SetType(CHlpFileEntry::EDiscarded);

										__PRINT_FILE(_L("Uid & name match, extensions differ.\n Saving entry tending to H01 which is"), *newEntry);

										}

									else

										{

										__PRINT_FILE(_L("Uid & name match, extensions differ.\n Discarding new entry because it tends to H99"), *newEntry);

										}

									}

								}

							else

								{

								// This entry should be treated as a separate entity from the current

								// existing entry because it has different uid's. Therefore, we just

								// move on to check against the next existing entry in the list

								__PRINT_FILE(_L("Duplicate name and extension, but different uids detected. New entry == "), *newEntry);

								continue;

								}

							}

						// Is the new entry a better match than the existing one?

						if	(newEntry->Type() < entry->Type())

							{

							// The new entry is of a better 'quality' than the existing

							// entry, so remove the old and add the new...

							__PRINT_FILE(_L("Removing stored (new better match found)"), *entry);

							//foundCollision = ETrue;

							masterList->Delete(j);

							delete entry;

							masterList->AppendL(newEntry);

							// Remove it from the new list as the master list now takes

							// ownership...

							list->Delete(k);

							break;

							}

						else

							{

							// This entry is of lower quality than an existing

							// entry in the master list, so we can safely discard it.

							delete newEntry;

							list->Delete(k);

							}

						continue;

						}

					}

				}

			// At this point, anything that is left int the new list should

			// be valid to add to the master list...

			TInt newListCount = list->Count();

			for(TInt k=newListCount-1; k>=0; k--)

				{

				__PRINT_FILE_NO(_L("Saving entry"), *list->At(k), k);

				masterList->AppendL(list->At(k));

				}

			// We only destroy the list, rather than list+contents because each element

			// in the new list is now guaranteed to be present in the master list.

			CleanupStack::PopAndDestroy(); // list

			}

		if	(i-- == EDriveZ)

			break;

		}

	// Print out the master list

	TheTest.Printf(_L("\n\nThe help files that would be loaded are:-"));

	TheTest.Printf(_L("\n========================================="));

	TInt masterCount = masterList->Count();

	for(i=0; i<masterCount; i++)

		__PRINT_FILE_NO(_L("Entry"), *masterList->At(i), i);

	masterList->ResetAndDestroy();

	CleanupStack::PopAndDestroy(); // masterList

	}

/**

@SYMTestCaseID PIM-TLOADER-0001 

*/

GLDEF_C TInt E32Main()

//

// Test Help file loading

//

    {

	__UHEAP_MARK;

	TheTest.Title();

	TheTest.Start(_L("@SYMTestCaseID PIM-TLOADER-0001"));