/*

* Copyright (c) 2009-2010 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:

*     Implementation to read from the config file.

*

*

*/

#include "config.h"

// ---------------------------------------------------------------------------

// WriteIntToConfigFile

//

// Write the given TUint32 value and tag into the given file.

//

// @return TInt normal Symbian error code or KErrNone if all went OK.

// ---------------------------------------------------------------------------

//

TInt WriteIntToConfigFile( RFile& aFile, const TDesC& aTag, const TUint32 aValue )

	{

	const TInt valueLength = 10; //Length of TUint32

	TBufC<valueLength> value;

	TPtr valuePtr = value.Des();

	valuePtr.AppendNum(aValue);

	TInt err = WriteToConfigFile( aFile, aTag, value );

	return err;

	}

// ---------------------------------------------------------------------------

// WriteToConfigFile

//

// Write the given value-tag pair into the given file.

//

// @return TInt normal Symbian error code or KErrNone if all went OK.

// ---------------------------------------------------------------------------

//

TInt WriteToConfigFile( RFile& aFile, const TDesC& aTag, const TDesC& aValue )

	{

	TFileText outTextFile;

	outTextFile.Set(aFile);

	HBufC* content = HBufC::New( aTag.Length() + aValue.Length());

	if(!content)

		{

		return KErrNoMemory;

		}

	CleanupStack::PushL(content);

	TPtr ptr(content->Des());

	ptr.Copy(aTag);

	ptr.Append(aValue);

	TInt err = outTextFile.Write(ptr);

	CleanupStack::PopAndDestroy(content);

	if( err != KErrNone)

		{

		return err;

		}

	return KErrNone;

	}

// ---------------------------------------------------------------------------

// EnsureNewLineAtEnd

//

// Add a newline character as a last character in the file.

//

// @return TInt normal Symbian error code or KErrNone if all went OK.

// ---------------------------------------------------------------------------

//

TInt EnsureNewLineAtEnd(RFile& aFile)

	{

	// Get last 2-bytes before EOF

	// to check for new line character

	TInt pos = -2;

	TInt err = aFile.Seek(ESeekEnd, pos);

	if(err != KErrNone)

		{

		return err;

		}

	TBuf8<2> buf;

	err = aFile.Read(buf);

	if(err != KErrNone)

		{

		return err;

		}

	// Ascii value of new line character is 10

	if(buf[0] != 10 )

		{

		TFileText outTextFile;

		outTextFile.Set(aFile);

		// Write will append newline character

		err = outTextFile.Write(KNullDesC);

		if( err != KErrNone)

			{

			return err;

			}

		}

	return KErrNone;

	}

// ---------------------------------------------------------------------------

// ReadConfigFile

//

// Reads the configuration file to aBuffer, aLineBuffer containing the pointers to lines.

//

// @return TInt normal Symbian error code or KErrNone if all went OK.

// ---------------------------------------------------------------------------

//

TInt ReadConfigFile(RFile& aFile, TDes& aBuffer, RArray< TPtrC >& aLineBuffer )

	{

	// Read text file into buffers

	TInt ret( KErrNone );

	TFileText tf;

	tf.Set( aFile );

	aBuffer.SetMax();

	TPtr ptr( aBuffer.MidTPtr( 0 ) );

	TInt used( 0 );

	do

		{

		ret = tf.Read( ptr );

		TInt len( ptr.Length() );

		if ( ( ret == KErrNone || ret == KErrEof ) && len > 0 )

			{

			// Store non-empty text line

			TInt err( aLineBuffer.Append( ptr ) );

			if ( err == KErrNone )

				{

				ptr.SetMax();

				ptr.Set( ptr.MidTPtr( len ) );

				ptr.Zero();

				used += len;

				}

			else

				{

				ret = err;

				}

			}

		}

	while ( ret == KErrNone );

	if ( ret == KErrEof )

		{

		// reached the end of file without any other error => this is OK

		ret = KErrNone;

		}

	aBuffer.SetLength( used );

	return ret;

	}

// ---------------------------------------------------------------------------

// ReadConfigFile

//

// @return HBufC containg the read config file. aLineBuffer arrays pointing to lines.

// ---------------------------------------------------------------------------

//

HBufC* ReadConfigFile( RFs& aFs, const TDesC& aFullPath, RArray< TPtrC >& aLineBuffer, TInt& aError )

	{

	RFile file;

	aError = file.Open( aFs, aFullPath, EFileRead | EFileStreamText | EFileShareReadersOnly );

	if ( aError != KErrNone )

		{

		return NULL;

		}

	TInt size( 0 );

	aError = file.Size( size );

	if ( aError != KErrNone )

		{

		file.Close();

		return NULL;

		}

	// Get text size, create buffer for text and read text file

	HBufC* ret = HBufC::New( ( size + sizeof( TText ) - 1 ) / sizeof( TText ) );

	if ( !ret )

		{

		aError = KErrNoMemory;

		file.Close();

		return NULL;

		}

	TPtr ptr( ret->Des() );

	aError = ReadConfigFile( file, ptr, aLineBuffer );

	file.Close();

	if ( aError != KErrNone )

		{

		delete ret;

		aLineBuffer.Reset();

		return NULL;

		}

	return ret;

	}

// ---------------------------------------------------------------------------

// GetConfigValue

//

// Gets string specified by tag. For examples:

// Tag1=Value1  Tag1 = aTag, Value1 will be copied to aTag

// aError Normal Symbian error code or KErrNone if all went OK.

// ---------------------------------------------------------------------------

//

TPtrC GetConfigValue( const TDesC& aTag, const RArray< TPtrC >& aLineBuffer, TInt& aError )

	{

	aError = KErrNotFound;

	TPtrC ret( KNullDesC );

	const TInt tagLen( aTag.Length() );

	const TInt count( aLineBuffer.Count() );

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

		{

		TPtrC line( aLineBuffer[ i ] );

		if ( !line.Left( tagLen ).CompareF( aTag ) )

			{

			ret.Set( line.Mid( tagLen ) );

			aError = KErrNone;

			break;

			}

		}

	return ret;

	}

TInt CompareVersions(TVersion& version1,TVersion& version2)

	{

	// Compare the versions based on major,minor and build number.

	if((version1.iMajor == version2.iMajor)&&(version1.iMinor == version2.iMinor)&&(version1.iBuild == version2.iBuild))

		{

		return EEqualVersion;

		}

	else if ((version1.iMajor > version2.iMajor) ||

			((version1.iMajor == version2.iMajor)&&(version1.iMinor > version2.iMinor)) ||

			((version1.iMajor == version2.iMajor)&&(version1.iMinor == version2.iMinor)&&(version1.iBuild >= version2.iBuild)))

		{

		return EGreaterFirstVersion;

		}

	else

		{

		return EGreaterSecondVersion;

		}

	}

TBool SetVersion(const TDesC8& aVersionPtr, TVersion& aVer)

	{

	// Function will return EFalse if aVersionPtr is not a valid

	// version string

	TLex8 lex(aVersionPtr);

	TInt count = 0;

	lex.SkipSpace();

	// Get Major Version (max length 3)

	const TInt maxMajorVersionLength = 3;

	lex.Mark();

	while ( (count<maxMajorVersionLength) && (lex.Peek() != '.') )

		{

		lex.Inc();

		++count;

		}

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

		{

		return EFalse;

		}

	TLex8 lexToken(lex.MarkedToken());

	if ( lexToken.Val(aVer.iMajor) != KErrNone )

		{

		return EFalse;

		}

	// Get Minor Version(max length 2)

	const TInt maxMinorVersionLength = 2;

	count = 0;

	lex.Inc();

	lex.Mark();

	while ( (count<maxMinorVersionLength) && (lex.Peek() != '.') )

		{

		lex.Inc();

		++count;

		}

	lexToken.Assign(lex.MarkedToken());

	if ( lexToken.Val(aVer.iMinor) != KErrNone )

		{

		return EFalse;

		}

	// Check if Build Number exists,

	// otherwise return

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

		 {

		 lex.Mark();

		 lex.SkipCharacters();

		 if (lex.TokenLength() > 0)

			 {

			 return EFalse;

			 }

		 else

			 {

			 aVer.iBuild = 0;

			 return ETrue;

			 }

		 }

	// Get Build Number(max length 5)

	const TInt maxBuildNoLength = 5;

	lex.Inc();

	lex.Mark();

	lex.SkipCharacters();

	if (lex.TokenLength() > maxBuildNoLength)

		{

		return EFalse;

		}

	lexToken.Assign(lex.MarkedToken());

	if ( lexToken.Val(aVer.iBuild) != KErrNone )

		{

		return EFalse;

		}

	return ETrue;

	}