// settings.cpp

// 

// Copyright (c) 2009 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/ioutils.h>

#include <fshell/settings.h>

using namespace LtkUtils;

void Panic(TSettingPanic aReason)

	{

	User::Panic(KSettingPanic, aReason);

	}

void RemoveSpaces(TDes& aDes)

	{

	for (TInt i=aDes.Length()-1; i>=0; --i)

		{

		if (TChar(aDes[i]).IsSpace()) aDes.Delete(i, 1);

		}

	}

/*

List of valid values for a boolean. Values interpreted as false, true, false, true, etc.

i.e. even poitions are false, odd true.

*/

_LIT(KBoolValues, "0,1,off,on,no,yes,false,true");

void HandleLineL(const TDesC& aLine, MValueHandler& aValueHandler, TErrorContext aErrorContext)

	{

	if (aLine.Length() == 0) return;

	if (aLine[0] == '#') // comment

		{

		aValueHandler.HandleCommentL(aLine.Mid(1), aErrorContext);

		}

	else

		{

		TLex lex(aLine);

		lex.SkipSpaceAndMark();

		lex.SkipCharacters();

		TPtrC id(lex.MarkedToken());

		lex.SkipSpace();

		TPtrC value(lex.Remainder());

		if (id.Length())

			{

			aValueHandler.HandleValueL(id, value, aErrorContext, EFalse);

			}

		}

	}

_LIT(KNewLine, "\n");

EXPORT_C void LtkUtils::ReadIniFileL(const TDesC& aFilename, MValueHandler& aValueHandler, TErrorContext aErrorContext, TFileNotFoundAction aNotFoundAction)

	{

	RFs fs;

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

	CleanupClosePushL(fs);

	IoUtils::TFileName2 fn(aFilename);

	TInt err = fn.FindFile(fs);

	if ((err == KErrNotFound) && (aNotFoundAction == ESucceedIfFileNotFound))

		{

		CleanupStack::PopAndDestroy(&fs);

		return;

		}

	StaticLeaveIfErr(err, _L("%SCannot find file '%S'"), &aErrorContext, &fn);

	RFile file;

	StaticLeaveIfErr(file.Open(fs, fn, EFileRead | EFileShareReadersOnly), _L("%SCannot open file '%S'"), &aErrorContext, &fn);

	CleanupClosePushL(file);

	IoUtils::CTextBuffer* buf = IoUtils::CTextBuffer::NewLC(0x40);

	TErrorContext context(fn);

	TBuf8<0x40> readBuf;

	do

		{

		TInt lineEnd;

		do 

			{

			const TDesC& des(buf->Descriptor());

			lineEnd = des.Find(KNewLine);

			if (lineEnd != KErrNotFound)

				{

				TPtrC line(des.Left(lineEnd));

				if (line.Length() > 0)

					{

					if (line[line.Length()-1] == '\r') line.Set(line.Left(line.Length()-1));

					HandleLineL(line, aValueHandler, context);					

					}

				buf->Delete(0, lineEnd+1);

				context.NextLine();

				}

			} while (lineEnd != KErrNotFound);

		User::LeaveIfError(file.Read(readBuf));

		buf->AppendL(readBuf);

		}

	while (readBuf.Length() > 0);

	CleanupStack::PopAndDestroy(3, &fs); // buf, file, fs

	}

EXPORT_C void LtkUtils::ReadIniFileL(RIoReadHandle& aReadHandle, MValueHandler& aValueHandler)

	{

	RBuf lineBuf;

	lineBuf.CreateL(0x100);

	CleanupClosePushL(lineBuf);

	aReadHandle.SetReadModeL(RIoReadHandle::ELine);

	TName name;

	aReadHandle.ObjectNameL(name);

	TInt err;

	TErrorContext context(name);

	while ((err = aReadHandle.Read(lineBuf))==KErrNone)

		{

		HandleLineL(lineBuf, aValueHandler, context);

		context.NextLine();

		}

	if (err!=KErrEof) User::LeaveIfError(err);

	CleanupStack::PopAndDestroy(&lineBuf);

	}

TInt ValueLineNumberOrder(const CValue& aRodger, const CValue& aMinnie)

	{

	return aRodger.LineNumber() - aMinnie.LineNumber();

	}

EXPORT_C void LtkUtils::WriteIniFileL(const TDesC& aFilename, CIniReader& aValues)

	{

	RFs fs;

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

	CleanupClosePushL(fs);

	RFile file;

	StaticLeaveIfErr(file.Replace(fs, aFilename, EFileWrite | EFileShareExclusive), _L("Cannot open '%S' for writing"), &aFilename);

	CleanupClosePushL(file);

	IoUtils::CTextFormatter* formatter = IoUtils::CTextFormatter::NewLC(KMaxTInt);

	aValues.AppendFirstLineL(formatter);

	RPointerArray<CValue> values;

	CleanupClosePushL(values);

	aValues.GetValuesL(values);

	values.Sort(TLinearOrder<CValue>(ValueLineNumberOrder));

	IoUtils::CTextBuffer* buf = IoUtils::CTextBuffer::NewLC(0x20);	

	for (TInt i=0; i<values.Count(); ++i)

		{

		buf->AppendFormatL(_L("%S\t%S\r\n"), &values[i]->Id(), &values[i]->Value());

		}

	formatter->TabulateL(0, 4, buf->Descriptor(), IoUtils::EIgnoreAvailableWidth);

	User::LeaveIfError(file.Write(formatter->Collapse()));

	CleanupStack::PopAndDestroy(5, &fs); // fs, file, values, buf, formatter

	}

//______________________________________________________________________________

//						TErrorContext

EXPORT_C TErrorContext::TErrorContext()

	: iFilename(KNullDesC), iLineNumber(0)

	{

	}

EXPORT_C TErrorContext::TErrorContext(const TDesC& aFilename)

	: iFilename(aFilename), iLineNumber(1)

	{

	}

EXPORT_C void TErrorContext::NextLine()

	{

	iLineNumber++;

	}

EXPORT_C TInt TErrorContext::LineNumber()

	{

	return iLineNumber;

	}

EXPORT_C const TDesC& TErrorContext::StringLC()

	{

	_LIT(KErrorContextFmt, "%S:%d: ");

	if (iFilename.Length() && iLineNumber>0)

		{

		HBufC* string = HBufC::NewLC(iFilename.Length()+0x10);

		string->Des().AppendFormat(KErrorContextFmt, &iFilename, iLineNumber);

		return *string;

		}

	else

		{

		CleanupStack::PushL((void*)NULL);

		return KNullDesC;

		}

	}

//______________________________________________________________________________

//						CValue

EXPORT_C CValue* CValue::NewL(const TDesC& aId, const TDesC& aValue, TErrorContext aErrorContext)

	{

	CValue* self = CValue::NewLC(aId, aValue, aErrorContext);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CValue* CValue::NewLC(const TDesC& aId, const TDesC& aValue, TErrorContext aErrorContext)

	{

	CValue* self = new(ELeave)CValue(aErrorContext);

	CleanupStack::PushL(self);

	self->ConstructL(aId, aValue);

	return self;

	}

EXPORT_C CValue::~CValue()

	{

	iId.Close();

	iValue.Close();

	}

EXPORT_C const TDesC& CValue::Id() const

	{

	return iId;

	}

EXPORT_C const TDesC& CValue::Value() const

	{

	return iValue;

	}

EXPORT_C void CValue::SetL(const TDesC& aNewValue, TErrorContext aErrorContext)

	{

	if (iValue.MaxLength() < aNewValue.Length())

		{

		RBuf newValue;

		newValue.CreateL(aNewValue.Length());

		newValue.Swap(iValue);

		newValue.Close();

		}

	if (aErrorContext.LineNumber() > 0) iLineNumber = aErrorContext.LineNumber();

	iValue.Copy(aNewValue);

	}

EXPORT_C TInt CValue::LineNumber() const

	{

	return iLineNumber;

	}

EXPORT_C TInt CValue::AsInt(TInt& aInt) const

	{

	TLex lex(iValue);

	TInt err = lex.Val(aInt);

	if (err == KErrNone)

		{

		if (lex.Remainder().Length()) err = KErrArgument;

		}

	return err;

	}

EXPORT_C TInt CValue::AsBool(TBool& aBool) const

	{

	IoUtils::TEnum truth(KBoolValues);

	TInt i;

	TInt err = truth.Parse(iValue, i);

	if (err==KErrNone)

		{

		aBool = i & 0x01;

		}

	return err;

	}

EXPORT_C TInt CValue::AsIntL() const

	{

	TInt i;

	StaticLeaveIfErr(AsInt(i), _L("'%S' value '%S' is not a valid integer"), &iId ,&iValue);

	return i;

	}

EXPORT_C TBool CValue::AsBoolL() const

	{

	TBool b;

	StaticLeaveIfErr(AsBool(b), _L("'%S' value '%S' is not a valid boolean"), &iId, &iValue);

	return b;

	}

CValue::CValue(TErrorContext aErrorContext)

	: iLineNumber(aErrorContext.LineNumber())

	{

	}

void CValue::ConstructL(const TDesC& aId, const TDesC& aValue)

	{

	iId.CreateL(aId);

	iValue.CreateL(aValue);

	}

//______________________________________________________________________________

//						CIniReader

EXPORT_C CIniReader* CIniReader::NewL(const TDesC& aFilename, TErrorContext aErrorContext)

	{

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

	CleanupStack::PushL(self);

	ReadIniFileL(aFilename, *self, aErrorContext, EFailIfFileNotFound);

	CleanupStack::Pop(self);

	return self;

	}

CIniReader::CIniReader()

	{

	}

EXPORT_C CIniReader::~CIniReader()

	{

	TPtrHashMapIter<TDesC, CValue> iter(iValues);

	while (iter.NextValue())

		{

		const CValue* val = iter.CurrentValue();

		iter.RemoveCurrent();

		delete val;

		}

	iValues.Close();

	iFirstLineComment.Close();

	}

EXPORT_C const TDesC* CIniReader::GetValue(const TDesC& aId) const

	{

	const CValue* value = iValues.Find(aId);

	if (value)

		{

		return &value->Value();

		}

	else

		{

		return NULL;

		}

	}

EXPORT_C void CIniReader::GetValuesL(RPointerArray<CValue>& aValues)

	{

	TPtrHashMapIter<TDesC, CValue> iter(iValues);

	while (iter.NextValue())

		{

		if (IncludeValue(iter.CurrentValue())) aValues.AppendL(iter.CurrentValue());

		}

	}

EXPORT_C void CIniReader::GetValuesL(RPointerArray<const CValue>& aValues) const

	{

	TPtrHashMapIter<TDesC, CValue> iter(iValues);

	while (iter.NextValue())

		{

		if (IncludeValue(iter.CurrentValue())) aValues.AppendL(iter.CurrentValue());

		}

	}

EXPORT_C void CIniReader::GetIdsL(RArray<const TPtrC>& aIds) const

	{

	TPtrHashMapIter<TDesC, CValue> iter(iValues);

	while (iter.NextValue())

		{

		aIds.AppendL(*iter.CurrentKey());

		}

	}

EXPORT_C void CIniReader::SetValueL(const TDesC& aId, const TDesC& aValue)

	{

	CValue* value = iValues.Find(aId);

	if (value)

		{

		value->SetL(aValue, TErrorContext());

		}

	else

		{

		HandleValueL(aId, aValue, TErrorContext(), ETrue);

		}

	}

EXPORT_C void CIniReader::RemoveValueL(const TDesC& aId)

	{

	CValue* value = iValues.Find(aId);

	if (value)

		{

		DoRemoveL(value);

		}

	}

void CIniReader::DoRemoveL(CValue* aValue)

	{

	iValues.Remove(&aValue->Id());

	delete aValue;

	}

void CIniReader::AppendFirstLineL(IoUtils::CTextFormatter* aFormatter)

	{

	if (iFirstLineComment.Length())

		{

		aFormatter->AppendFormatL(_L("#%S\r\n"), &iFirstLineComment);

		}

	}

void CIniReader::HandleValueL(const TDesC& aId, const TDesC& aValue, TErrorContext aErrorContext, TBool aOverwrite)

	{

	CValue* value = iValues.Find(aId);

	if (!value)

		{

		value = CreateValueLC(aId, aValue, aErrorContext);

		iValues.InsertL(&value->Id(), value);

		CleanupStack::Pop(value);

		}

	else

		{

		if (aOverwrite)

			{

			value->SetL(aValue, aErrorContext);

			}

		// else ignore the duplicate value

		}

	}

void CIniReader::HandleCommentL(const TDesC& aComment, TErrorContext aErrorContext)

	{

	if (aErrorContext.LineNumber() == 1)

		{

		iFirstLineComment.Close();

		iFirstLineComment.CreateL(aComment);

		HandleFirstLineCommentL(iFirstLineComment, aErrorContext);

		}

	}

CValue* CIniReader::CreateValueLC(const TDesC& aId, const TDesC& aValue, TErrorContext aErrorContext)

	{

	return CValue::NewLC(aId, aValue, aErrorContext);

	}

//______________________________________________________________________________

//						CSetting

EXPORT_C CSetting* CSetting::NewL(TSettingType aType, const TDesC& aId, const TDesC& aName, const TDesC& aDescription, const TDesC& aDefault, const TDesC& aEnumValues, TErrorContext aErrorContext)

	{

	CSetting* self = CSetting::NewLC(aType, aId, aName, aDescription, aDefault, aEnumValues, aErrorContext);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSetting* CSetting::NewLC(TSettingType aType, const TDesC& aId, const TDesC& aName, const TDesC& aDescription, const TDesC& aDefault, const TDesC& aEnumValues, TErrorContext aErrorContext)

	{

	CSetting* self = new(ELeave)CSetting(aType);

	CleanupStack::PushL(self);

	self->ConstructL(aId, aName, aDescription, aDefault, aEnumValues, aErrorContext);

	return self;

	}

EXPORT_C CSetting::~CSetting()

	{

	iName.Close();

	iDescription.Close();

	iEnumValues.Close();

	iDefault.Close();

	}

EXPORT_C void CSetting::SetL(const TDesC& aNewValue, TErrorContext aErrorContext)

	{

	TInt value = ParseL(aNewValue, aErrorContext);

	switch (iType)

		{

	case ETypeEnum:

			{

			CValue::SetL(iEnum.GetString(value), aErrorContext);

			iIntValue = value;

			}

		break;

	case ETypeFilename:

	case ETypeString:

		CValue::SetL(aNewValue, aErrorContext);

		break;

	case ETypeInteger:

			{

			CValue::SetL(aNewValue, aErrorContext);

			iIntValue = value;

			}

		break;

	case ETypeBoolean:

			{

			IoUtils::TEnum truth(KBoolValues);

			TInt value = truth.ParseL(aNewValue); // even false, odd true

			CValue::SetL(truth.GetString(value), aErrorContext);

			iIntValue = (value & 0x01) ? (TBool)ETrue : EFalse;

			}

		break;

		}

	iIsSet = ETrue;

	}

TInt CSetting::ParseL(const TDesC& aValue, TErrorContext aErrorContext)

	{

	switch (iType)

		{

	case ETypeEnum:

			return iEnum.ParseL(aValue);

	case ETypeFilename:

	case ETypeString:

		return 0;

	case ETypeInteger:

			{

			TLex lex(aValue);

			TInt value;

			lex.SkipSpace();

			StaticLeaveIfErr(lex.Val(value), _L("%S'%S' value '%S' is not a valid integer"), &aErrorContext.StringLC(), &Id(), &aValue);

			lex.SkipSpace();