// 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);
		}
	}