// 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 "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 <e32std.h>

#include "server.h"

#include "inifile.h"

// uncomment so that if the wsini.ini file is not found on drive Wserv loaded from or drive Z: (if different)

// it will be searched for on drive C: (if different from Wserv's drive)

//#define LOAD_INI_FILE_FROM_DRIVE_Z_OR_C

GLREF_D CDebugLogBase *wsDebugLog;

_LIT(KDefaultSectionName,"DEFAULT");

_LIT(KCommentMarker,"//");

_LIT(KScreenSectionName,"SCREEN");

const TUint16 KNewSection('[');

const TUint16 KSpaceChar(' ');

const TUint16 KNewSection2(']');

const TInt KDefaultSectionNumber(0);

const TInt KDefaultScreenId(-1);

CIniFile::CIniFile()

	{}

CIniFile::~CIniFile()

	{

	FreeData();

	}

CIniSection * CIniFile::FindSection(TInt aScreen)

	{

	for (TInt sect = 0; sect < iSectionArray.Count(); ++sect)

		{

		if (iSectionArray[sect]->Screen() == aScreen)

			{

			return iSectionArray[sect];

			}

		}

	return NULL;

	}

CIniSection * CIniFile::FindSection(const TDesC& aName)

	{

	for (TInt sect = 0; sect < iSectionArray.Count(); ++sect)

		{

		if (iSectionArray[sect]->Screen() == KDefaultScreenId && !iSectionArray[sect]->Name().CompareF(aName))

			{

			return iSectionArray[sect];

			}

		}

	return NULL;

	}

/* Processes a .ini file entry section name.

 @return the corresponding index.

 @param aLine Input line of text from the .ini file, stripped of comments & excess whitespace.

 @leave KErrNoMemory

 */

CIniSection * CIniFile::AddOrFindIniSectionL(TPtr& aSectionName)

	{

	aSectionName.Trim();

	// DEFAULT section

	if (aSectionName.CompareF(KDefaultSectionName) == 0)

		{ 

		return iSectionArray[KDefaultSectionNumber];

		}

	// SCREENx section

	if (0 == aSectionName.FindF(KScreenSectionName))

		{

		TLex lex(aSectionName.Mid(KScreenSectionName().Length()));

		TInt screenNum;

		lex.SkipSpace();

		if (lex.Val(screenNum) == KErrNone)

			{

			return AddOrFindScreenSectionL(screenNum);

			}

		}

	// other section

	return AddOrFindNamedSectionL(aSectionName);

	}

CIniSection * CIniFile::CreateSectionL(TInt aScreen)

	{

	CIniSection* newSection = new (ELeave) CIniSection(aScreen);

	CleanupStack::PushL( newSection ) ;

	newSection->ConstructL() ;

	User::LeaveIfError(iSectionArray.Append(newSection));

	CleanupStack::Pop( newSection ) ;

	if (aScreen + 1 > iScreenCount)

		iScreenCount = aScreen + 1;

	return newSection;

	}

CIniSection * CIniFile::CreateSectionL(const TDesC& aName)

	{

	CIniSection* newSection = new (ELeave) CIniSection(KDefaultScreenId);

	CleanupStack::PushL( newSection ) ;

	newSection->ConstructL(aName) ;

	User::LeaveIfError(iSectionArray.Append(newSection));

	CleanupStack::Pop( newSection ) ;

	return newSection;

	}

void CIniFile::doConstructL(RFile &aFile)

	{

	TFileText textFile;

	textFile.Set(aFile);

	const TInt KMaxIniLine=256;

	TBuf<KMaxIniLine> readLine;

	TBool first=ETrue;

	// always have a [DEFAULT] section

	CIniSection * currentSection = CreateSectionL(KDefaultSectionName);

	FOREVER

		{

		TInt err=textFile.Read(readLine);

		if (err==KErrEof)

			break;

		User::LeaveIfError(err);

		if (readLine.Length()>0)

			{

			if (first && (readLine[0]==0xFFFE || readLine[0]==0xFEFF))

				readLine.Delete(0,1);

			// Comment marker "//" indicates the rest of the line should be discarded

			TInt commentStart = readLine.Find(KCommentMarker);

			if (commentStart != KErrNotFound)

				{

				readLine.Delete(commentStart, readLine.Length());

				}

			// compact unnecessary whitespace

			readLine.TrimAll();

			// anything left in buffer?

			if (readLine.Length() > 0)

				{

				// section name requires "[" and "]"

				if (readLine[0] == KNewSection && readLine.LocateReverse(KNewSection2) == readLine.Length() - 1)

					{

					TPtr nameText = readLine.MidTPtr(1, readLine.Length() - 2); // strip [ and ]

					currentSection = AddOrFindIniSectionL(nameText);

					}

				else

					{

					if (currentSection)

						{

						currentSection->AddVariableL(readLine);

						}

					}

				}

			first=EFalse;

			}

		}

	if (iScreenCount == 0)

		{

		iScreenCount = 1;

		}

	}

CIniFile* CIniFile::NewL()

    {

    CIniFile* self = new (ELeave) CIniFile();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CIniFile::FreeData() 

	{

	iSectionArray.ResetAndDestroy() ;

	iScreenCount = 0;

	}

void errFreeData(TAny *aIniFile)

	{

	((CIniFile *)aIniFile)->FreeData();

	}

HBufC* IniFileSearchPathLC()

	{

	_LIT(KPath,"\\SYSTEM\\DATA\\");

	_LIT(KPathSep,";");

	const TInt KLengthPerPath = 2 + KPath().Length();

	// work out which drive Wserv loaded from

	RProcess self;

	TFileName myPath = self.FileName();

	TParsePtrC myDrive(myPath);

	TDriveUnit myDriveUnit(myDrive.Drive());

	// need extra buffer space for search paths for drives Z: or C: ?

#if defined(LOAD_INI_FILE_FROM_DRIVE_Z_OR_C)

	TInt numPaths = 2;

	if (myDriveUnit != EDriveZ && myDriveUnit != EDriveC)

		{

		numPaths += 1;

		}

#else

	TInt numPaths = 1;

	if (myDriveUnit != EDriveZ)

		{

		numPaths += 1;

		}

#endif

	HBufC* searchPath = HBufC::NewLC(numPaths * KLengthPerPath + (numPaths - 1) * KPathSep().Length());

	TPtr pPath(searchPath->Des());

	pPath.Append(myDrive.Drive());

	pPath.Append(KPath);

	if (myDriveUnit != EDriveZ)

		{

		pPath.Append(KPathSep);

		pPath.Append(TDriveUnit(EDriveZ).Name());

		pPath.Append(KPath);

		}

#if defined(LOAD_INI_FILE_FROM_DRIVE_Z_OR_C)

	if (myDriveUnit != EDriveC)

		{

		pPath.Append(KPathSep);

		pPath.Append(TDriveUnit(EDriveC).Name());

		pPath.Append(KPath);

		}

#endif

	return searchPath;

	}

void CIniFile::ConstructL()

	{

	TAutoClose<RFs> fs;

	User::LeaveIfError(fs.iObj.Connect());

	fs.iObj.SetNotifyUser(EFalse);

	fs.PushL();

	HBufC* searchPath = IniFileSearchPathLC();

	_LIT(KFileName,"WSINI.INI");

	TFindFile findinifile(fs.iObj);

	TInt err=findinifile.FindByPath(KFileName,searchPath);

	User::LeaveIfError(err);

	CleanupStack::PopAndDestroy(searchPath);

 	TAutoClose<RFile> file;

	User::LeaveIfError(file.iObj.Open(fs.iObj,findinifile.File(),EFileStreamText|EFileRead));

	file.PushL();

	CleanupStack::PushL(TCleanupItem(errFreeData,this));

	doConstructL(file.iObj);

	CleanupStack::Pop(); // TCleanupItem

	file.Pop();

	fs.Pop();

	}

/* If the Section for the screen exists find the data, otherwise create a new data structure.

 @param aScreen Screen number

 @return index to section

 @leave KErrNoMemory

 */

CIniSection * CIniFile::AddOrFindScreenSectionL(TInt aScreen)

	{

	CIniSection * section = FindSection(aScreen);

	if (!section)

		section = CreateSectionL(aScreen);

	return section;

	}

/* If the Section exists find the data, otherwise create a new data structure.

 @param aName section name

 @return index to section

 @leave KErrNoMemory

 */

CIniSection * CIniFile::AddOrFindNamedSectionL(const TDesC& aName)

	{

	CIniSection * section = FindSection(aName);

	if (!section)

		section = CreateSectionL(aName);

	return section;

	}

TBool CIniFile::FindVar(const TDesC &aVarName, TPtrC &aResult)

	{

	return iSectionArray[KDefaultSectionNumber]->FindVar(aVarName, aResult);

	}

TBool CIniFile::FindVar(const TDesC &aVarName, TInt &aResult)

	{

	return iSectionArray[KDefaultSectionNumber]->FindVar(aVarName, aResult);

	}

TBool CIniFile::FindVar(const TDesC &aVarName)

//

// Used to simply detect the presence of the specified variable name

//

	{

	TPtrC ptr(NULL,0);

	return FindVar(aVarName, ptr);

	}

// FindVar in [SCREENx] sections

TBool CIniFile::FindVar( TInt aScreen, const TDesC &aVarName)

	{

	TPtrC ptr(NULL,0);

	return FindVar(aScreen, aVarName, ptr);

	}

TBool CIniFile::FindVar( TInt aScreen, const TDesC& aVarName, TPtrC &aResult )

	{

	CIniSection * section = FindSection(aScreen);

	TBool found = EFalse;

	if (section)

		found = section->FindVar(aVarName, aResult);

	if (!found)

		found = FindVar(aVarName, aResult);

	return found;

	}

TBool CIniFile::FindVar(TInt aScreen, const TDesC &aVarName, TInt &aResult)

	{

	CIniSection * section = FindSection(aScreen);

	TBool found = EFalse;

	if (section)

		found = section->FindVar(aVarName, aResult);

	if (!found)

		found = FindVar(aVarName, aResult);

	return found;

	}

// FindVar in named sections

TBool CIniFile::FindVar(const TDesC& aSectionName, const TDesC &aVarName)

	{

	TPtrC ptr(NULL,0);

	return FindVar(aSectionName, aVarName, ptr);

	}

TBool CIniFile::FindVar(const TDesC& aSectionName, const TDesC& aVarName, TPtrC &aResult )

	{

	CIniSection * section = FindSection(aSectionName);

	TBool found = EFalse;

	if (section)

		found = section->FindVar(aVarName, aResult);

	if (!found)

		found = FindVar(aVarName, aResult);

	return found;

	}

TBool CIniFile::FindVar(const TDesC& aSectionName, const TDesC &aVarName, TInt &aResult)

	{

	CIniSection * section = FindSection(aSectionName);

	TBool found = EFalse;

	if (section)

		found = section->FindVar(aVarName, aResult);

	if (!found)

		found = FindVar(aVarName, aResult);

	return found;

	}

TInt CIniFile::NumberOfScreens() const 

	{

  	return iScreenCount;

	}

// CIniSection.

// ini file structure is now in sections like this

//

// [DEFAULT]

// varname value

// varname2 value2

// [SCREEN0]

// screenvar value

// etc

//

// CIniSection represents a section - i.e. section name and content pairs.  

// Content pairs are as ini file was previously (so use same code)

// [default] section name is optional to support backwards compatibility

// if no sutable value is found in a [screenN] section the [default] section will be searched.

CIniSection::CIniSection(TInt aScreen) : iScreen(aScreen)

	{}

void CIniSection::ConstructL()

	{

	iPtrArray = new (ELeave) CArrayPtrFlat<TDesC>(8) ;

	}

void CIniSection::ConstructL(const TDesC& aName)

	{

	iName.CreateL(aName);

	ConstructL();

	}

CIniSection::~CIniSection()

	{

	iName.Close();

	iPtrArray->ResetAndDestroy() ;

	delete iPtrArray ;

	}

inline TInt CIniSection::Screen() const

	{ return iScreen; }

inline const TDesC& CIniSection::Name() const

	{ return iName; }

TBool CIniSection::FindVar( const TDesC& aVarName, TPtrC &aResult )

	{

	if (iPtrArray)

		{

		TInt index(KErrNotFound);

		if (FindVarName(aVarName, index))

			{

			TLex lex((*iPtrArray)[index]->Mid(aVarName.Length()));

			lex.SkipSpace();

			aResult.Set(lex.Remainder());

			if (wsDebugLog)

				{

				wsDebugLog->IniFileSettingRead(iScreen, aVarName, ETrue, aResult);

				}

			return(ETrue);

			}

		}

	if (wsDebugLog)

		{

		wsDebugLog->IniFileSettingRead(iScreen, aVarName, EFalse, KNullDesC);

		}

	return(EFalse);

	}

/*

 create a TPtrC with just the first word (variable name) in the given string

 */

TPtrC CIniSection::VarName(const TDesC& aVarString)

	{

	TInt varLength = aVarString.Locate(KSpaceChar);

	if (varLength == KErrNotFound)

		{

		varLength = aVarString.Length();

		}

	return aVarString.Left(varLength);

	}

TBool CIniSection::FindVar(const TDesC &aVarName, TInt &aResult)

	{

	TPtrC ptr(NULL,0);

	// do text Find

	if (FindVar(aVarName, ptr))

		{

		TLex lex(ptr);

		_LIT(HexFormatCheck,"0x");

		TPtrC hexPtr(HexFormatCheck);

		if(ptr.Left(2) != hexPtr)

			{

			if (lex.Val(aResult) == KErrNone)

				{

				return ETrue;

				}

			}

		else

			{

			lex.SkipAndMark(2); //To skip 0x in hex code

			if (lex.Val((TUint32&)aResult, EHex) == KErrNone)

				{

				return ETrue;

				}

			}

		}

	return EFalse;

	}

/*

 Find variable name in sorted array, using binary search

 @param aVarName variable name to search for, must have any space and variable value stripped.

 @param aIndex output index of matching or preceeding item

 @return

 */

TBool CIniSection::FindVarName(const TDesC& aVarName, TInt& aIndex)

	{

	// Binary Search

	// left is lowest index to include, right is highest index + 1;

	TInt left = 0;

	TInt right = iPtrArray->Count();

	while (right > left)

		{

		TInt middle = (left + right)>>1;

		// compare to start of variable string

		TPtrC cmpString = VarName(*(*iPtrArray)[middle]);

		TInt cmp = aVarName.CompareF(cmpString);

		if (cmp == 0)

			{

			aIndex = middle;

			return ETrue;

			}

		else if (cmp > 0)

			{

			left = middle + 1;

			}

		else

			{

			right = middle;

			}

		}

	aIndex = right;

	return EFalse;

	}

void CIniSection::AddVariableL(const TDesC& aNewVariable)

	{

	// use variable name only for search

	TPtrC varName = VarName(aNewVariable);

	TInt index(0);

	// ignore duplicate definitions

	if (0 == FindVarName(varName, index))

		{ // insert in sorted array

		HBufC* hbuf = aNewVariable.AllocLC() ;

		iPtrArray->InsertL(index, hbuf);

		CleanupStack::Pop(hbuf);

		}

	}