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

//

/**

 @file 

 @internalComponent

*/

#include <f32file.h>

#include "CIniFile.h"

#include "dbdef.h"

CIniData::CIniData() 

/**

Default constructor

*/

	: iPtr(NULL,0), section(NULL,0), block(NULL,0), BlockState(E_UNKNOWN),

	  blockStart(0), blockEnd(0), scanStart(0)

	{

	__DECLARE_NAME(_S("CIniData"));

	}

CIniData::~CIniData()

/**

Destructor

*/

	{

	delete (TText*)iPtr.Ptr();

	delete iToken;

	delete iName;

	}

CIniData* CIniData::NewL(const TDesC& aName)

/**

Allocates and constructs a new CIniData object

@param aName Name of the ini file to be read

@return A newly created CIniData object

*/

	{

	CIniData* p = new(ELeave) CIniData;

	CleanupStack::PushL(p);

	p->ConstructL(aName);

	CleanupStack::Pop(p);

	return p;

	}

void CIniData::ConstructL(const TDesC& aName)

/**

Allocates a buffer and reads file's contents into iPtr

@param aName Name of the ini file to be read

*/

	{

 	// Allocate space for token

	iToken=HBufC::NewL(MAX_COL_NAME_LEN + 2);	// 2 extra chars for [tokenName]

	// Connect to file server

	TAutoClose<RFs> fs;

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

	fs.PushL();

	// Find file, given name

	TFindFile ff(fs.iObj);

	User::LeaveIfError(ff.FindByPath(aName, NULL));

	iName=ff.File().AllocL();

	// Open file

	TAutoClose<RFile> file;

	TInt size;

	User::LeaveIfError(file.iObj.Open(fs.iObj,*iName,EFileStreamText|EFileRead));

	file.PushL();

	// Get file size and read in

	User::LeaveIfError(file.iObj.Size(size));

	TText* data=(TText*)User::AllocL(size);

	iPtr.Set(data, TUint(size)/sizeof(TText), TUint(size)/sizeof(TText));

	TPtr8 dest((TUint8*)data, 0, size);

	User::LeaveIfError(file.iObj.Read(dest));

	TUint8* ptr = (TUint8*)data;

	//

	// This is orderred as FEFF assuming the processor is Little Endian

	// The data in the file is FFFE.		PRR 28/9/98

	//

	if(size>=(TInt)sizeof(TText) && iPtr[0]==0xFEFF)

		{

		// UNICODE Text file so lose the FFFE

		Mem::Copy(ptr, ptr+sizeof(TText), size-sizeof(TText));

		iPtr.Set(data, TUint(size)/sizeof(TText)-1, TUint(size)/sizeof(TText)-1);

		}

	else if(size)

		{

		// NON-UNICODE so convert to UNICODE

		TText* newdata = (TText*)User::AllocL(size*sizeof(TText));

		iPtr.Set(newdata, size, size);

		TInt i;

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

			{

			iPtr[i]=ptr[i];

			}

		delete data;

		}

	file.Pop();

	fs.Pop();

	}

TInt CIniData::OpenSetBlock(const TDesC &aSection)

/**

Locates and opens a section for 'updates'

@param aSection Section to work with

@return ETrue if successful or EFalse

*/

	{

	BlockState = E_SET;

	return OpenBlock(aSection);

	}

TInt CIniData::OpenTemplateBlock(const TDesC &aSection)

/**

Locates and opens a section for 'template'

@param aSection Section to work with

@return ETrue if successful or EFalse

*/

	{

	BlockState = E_TEMPLATE;

	return OpenBlock(aSection);

	}

TInt CIniData::OpenAddBlock(const TDesC &aSection)

/**

Locates and opens a section for 'adds'

@param aSection Section to work with

@return ETrue if successful or EFalse

*/

	{

	BlockState = E_ADD;

	return OpenBlock(aSection);

	}

TInt CIniData::OpenBlock(const TDesC &aSection)

/**

Reads in the entire table section of all ADD / SET blocks into 'section'

@param aSection Section to work with

@return ETrue if successful or EFalse

*/

	{

    if (BlockState != E_UNKNOWN)

		{

	    blockStart = 0;

	    blockEnd = 0;

	    scanStart = 0;

	    TPtr sectionToken = iToken->Des();

		_LIT(sectionTokenString,"[%S]");

		sectionToken.Format(sectionTokenString,&aSection);

	    // locate the section

		TInt sectionStart = iPtr.FindF(sectionToken);

	    if (sectionStart == KErrNotFound)

			{

	        return EFalse;

			}

		// step to the end of the section name

		TPtrC tempSection = iPtr.Mid(sectionStart);

        sectionStart += tempSection.Find(TPtrC(_S("]")));

		if (sectionStart == KErrNotFound)

			{

			return EFalse;

			}

		sectionStart++;

		// we are now at the start of the section data

        tempSection.Set(iPtr.Mid(sectionStart));

		// loop until we reach the end of the section

		TUint32 i=0;

		TUint32 lMaxLen = tempSection.Length();

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

			{

	        if (tempSection.Ptr()[i] == '[' &&

		        tempSection.Ptr()[i - 1] != '\\')

				{

			    i--;

			    break;

				}

			}

		// set the actual section to work with

        tempSection.Set(iPtr.Mid(sectionStart, i));

		section.Set((unsigned short *)tempSection.Ptr(), tempSection.Length(), tempSection.Size());

		}

	return StepToNextBlock();	// find the first block

	}

TInt CIniData::StepToNextBlock()

/**

Locates the next available block of data within a section

@return ETrue if successful or EFalse

*/

	{

	if (BlockState != E_UNKNOWN)

		{

		// get unscanned portion of the section

		TPtrC temp = section.Mid(scanStart);

		// find the start of the next block

		if (BlockState == E_SET)

			{

			blockStart = temp.FindF(TPtrC(BEGIN_SET));

			blockEnd = temp.FindF(TPtrC(END_SET));

			}

		else if (BlockState == E_TEMPLATE)

			{

			blockStart = temp.FindF(TPtrC(BEGIN_TEMPLATE));

			blockEnd = temp.FindF(TPtrC(END_TEMPLATE));

			}

		else if (BlockState == E_ADD)

			{

			blockStart = temp.FindF(TPtrC(BEGIN_ADD));

			blockEnd = temp.FindF(TPtrC(END_ADD));

			}

		if (blockStart != KErrNotFound && blockEnd != KErrNotFound)

			{

			// set the start point for the next block search

			scanStart += blockEnd;

			scanStart++;

			// set the actual block to work with

			blockEnd -= blockStart;

			TPtrC tempBlock = temp.Mid(blockStart,blockEnd);

			block.Set((unsigned short *)tempBlock.Ptr(), tempBlock.Length(), tempBlock.Size());

			return ETrue;

			}

		}

	return EFalse;

	}

TInt CIniData::GetSetting(const TDesC &aValue, TPtrC &aSetting)

/**

Retrieves the value for a particular setting within a block

@param aValue The setting to be retrieved 

@param aSetting On return it contains the value for the setting

@return KErrNone if successful or KErrArgument for fields simply left blank. If the global BlockState is unknown returns KErrNotReady.

*/

	{

	TInt valid(KErrNotReady);	

	if (BlockState != E_UNKNOWN)

	    {

		// first check for CONDITION field

		// if we are NOT looking for this field, we need to trim off any condition

		// field from the block because there may be a setting within it we 

		// want to ignore during our search for this field

        TPtrC pBlock(block);

		TInt tempEnd = blockEnd;

		TPtrC Condition = CONDITION;

		if (aValue.Compare(Condition) != 0)

		    {

			TPtr varCondToken = iToken->Des();

			_LIT(varCondTokenString, "%S=");

			varCondToken.Format(varCondTokenString, &Condition);

			TInt CondPos = pBlock.FindF(varCondToken);

			if (CondPos != KErrNotFound)

				{

				tempEnd = CondPos;

				}

		    }

		// now look for the actual value

        TBool searchAgain = EFalse;

        _LIT(varTokenString, "%S=");

		TPtr varToken = iToken->Des();

		varToken.Format(varTokenString, &aValue);

        TInt pos = KErrNotFound;

        do

            {

            searchAgain = EFalse;

            pos = pBlock.FindF(varToken);

		    if (pos != KErrNotFound && pos < tempEnd)

		        {

                // check that this is a complete match, not a substring

                // match against another similar field, e.g. LoginScript

                // must only match against "LoginScript" not "UseLoginScript"

                if  (pos > 0)

                    {

                    // Previous character must be white space

                    const TChar previousCharacter = pBlock[pos - 1];

                    if  (previousCharacter.IsSpace())

                        {

			            // make sure we haven't overrun our block

			            TInt length = varToken.Length();

			            if (pos + length < tempEnd)

			                {

				            TLex lex(pBlock.Mid(pos + length));

				            // if enclosed by quotes, extract the text within

				            if (lex.Peek() == '"')

				                {

					            lex.SkipAndMark(1);			// start of data

					            // stop at end of quote or line

					            while(lex.Peek() != '"' && lex.Peek() != 10 && lex.Peek() != 13)

									{

						            lex.Inc();

									}

				                }

							else if(lex.Peek() == 10 || lex.Peek() == 13)	// skip empty or blank field value

								{

								return KErrArgument;

								}

							else	// skip any unwanted spaces or tabs in a field value

								{

								TBool fieldValFound=EFalse;

								while(lex.Peek() != 10 && lex.Peek() != 13) 

									{

									if(!fieldValFound)

										{

										while(lex.Peek() == 9 || lex.Peek() == 32) // skip any space or a tab

											{

											lex.SkipAndMark(1);

											}

										if(lex.Peek() == 10 || lex.Peek() == 13) // field value simply filled with space or tab

											{

											return KErrArgument;

											}

										}

									fieldValFound=ETrue;	// start of real data

									lex.Inc();

									}

								}

				            aSetting.Set(lex.MarkedToken().Ptr(),lex.MarkedToken().Length());

							valid = KErrNone;

                            }

                        }

                    else

                        {

                        // E.g. LoginScript matched against UseLoginScript -> must look

                        // for another match after the current one

                        pBlock.Set(pBlock.Mid(pos+1));

                        searchAgain = ETrue;

                        }

                    }

			    }

            }

        while(searchAgain);

	    }

	return valid;

    }