/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

* This file implements a package file parser for the Reference Installer.

*

*/

#include "sifrefpkgparser.h"

#include <f32file.h>

#include "usiflog.h"

#include <usif/usiferror.h>

using namespace Usif;

/**

A set of helper functions for the parser.

*/

namespace

	{

	_LIT8(KTxtCRLF, "\r\n");

	_LIT8(KTxtLanguages, "Languages");

	_LIT8(KTxtComponentName, "ComponentName");

	_LIT8(KTxtComponentVendor, "ComponentVendor");

	_LIT8(KTxtComponentVersion, "ComponentVersion");

	_LIT8(KTxtFile, "File");

	/** Maximum length of a value string in a package file */

	const TInt KMaxValueLength = 0xFF;

	void SplitLineL(const TPtrC8& aLine, TPtrC8& aName, TPtrC8& aValue)

		{

		const TInt colon = aLine.Locate(':');

		if (colon == KErrNotFound)

			{

			DEBUG_PRINTF2(_L8("Missing colon in line: %S"), &aLine);

			User::Leave(KErrCorrupt);

			}

		aName.Set(aLine.Left(colon));

		aValue.Set(aLine.Mid(colon+1));

		}

	void SplitValuesL(const TPtrC8& aValues, RCHBufCArray& aValueArray)

		{

		TPtrC8 values(aValues);

		while (values.Size() > 0)

			{

			TInt quot = values.Locate('"');

			if (quot == KErrNotFound)

				{

				return;

				}

			values.Set(values.Mid(quot+1));

			quot = values.Locate('"');

			if (quot == KErrNotFound)

				{

				DEBUG_PRINTF2(_L8("Missing closing quotation mark in line: %S"), &aValues);

				User::Leave(KErrCorrupt);

				}

			TPtrC8 token(values.Left(quot));

			HBufC* value = HBufC::NewLC(KMaxValueLength);

			TPtr valPtr(value->Des());

			valPtr.Copy(token);

			aValueArray.AppendL(value);

			CleanupStack::Pop(value);

			values.Set(values.Mid(quot+1));

			}

		}

	void ParseComponentVersionL(const TPtrC8& aStringVersion, TVersion& aVersion)

		{

		// Check if already defined

		if (aVersion.iMajor || aVersion.iMinor || aVersion.iBuild)

			{

			DEBUG_PRINTF(_L8("Multiple definition of Component Version"));

			User::Leave(KErrCorrupt);

			}

		// Convert the major version number of Component Version

		TLex8 lex(aStringVersion);

		lex.SkipSpace();

		TInt err = lex.Val(aVersion.iMajor);

		if (err != KErrNone)

			{

			DEBUG_PRINTF(_L8("Failed parsing the major version number of Component Version"));

			User::LeaveIfError(err);

			}

		lex.Inc();

		// Convert the minor version number of Component Version

		err = lex.Val(aVersion.iMinor);

		if (err != KErrNone)

			{

			DEBUG_PRINTF(_L8("Failed parsing the minor version number of Component Version"));

			User::LeaveIfError(err);

			}

		lex.Inc();

		// Convert the build version number of Component Version

		err = lex.Val(aVersion.iBuild);

		if (err != KErrNone)

			{

			DEBUG_PRINTF(_L8("Failed parsing the build version number of Component Version"));

			User::LeaveIfError(err);

			}

		}

	TLanguage LanguageMapL(TDesC& aLanguage)

		{

		if (aLanguage == _L("EN"))

			{

			return ELangEnglish;

			}

		else if (aLanguage == _L("HU"))

			{

			return ELangHungarian;

			}

		else if (aLanguage == _L("PL"))

			{

			return ELangPolish;

			}

		DEBUG_PRINTF2(_L8("Language %S is not supported by this Reference Installer"), &aLanguage);

		User::Leave(KErrSifUnsupportedLanguage);

		return ELangNone;// Suppress warning

		}

	}

CSifRefPkgParser* CSifRefPkgParser::NewL(const TDesC& aFileName)

	{

	CSifRefPkgParser* self = new (ELeave) CSifRefPkgParser;

	CleanupStack::PushL(self);

	self->ParseL(aFileName);

	CleanupStack::Pop(self);

	return self;

	}

CSifRefPkgParser::CSifRefPkgParser(): iVersion(0, 0, 0)

	{

	}

CSifRefPkgParser::~CSifRefPkgParser()

	{

	iLanguages.Close();

	iComponentNames.Close();

	iVendorNames.Close();

	iFiles.Close();

	}

const RLanguageArray& CSifRefPkgParser::Languages() const

	{

	return iLanguages;

	}

const RCHBufCArray& CSifRefPkgParser::ComponentNames() const

	{

	return iComponentNames;

	}

const RCHBufCArray& CSifRefPkgParser::VendorNames() const

	{

	return iVendorNames;

	}

const TVersion& CSifRefPkgParser::Version() const

	{

	return iVersion;

	}

const RCHBufCArray& CSifRefPkgParser::Files() const

	{

	return iFiles;

	}

void CSifRefPkgParser::ParseL(const TDesC& aFileName)

	{

	RFs fs;

	RFile file;

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

	CleanupClosePushL(fs);

	TInt err = file.Open(fs, aFileName, EFileShareReadersOnly);

	if (err != KErrNone)

		{

		DEBUG_PRINTF3(_L8("Failed to open file: %S with error: %d"), &aFileName, err);

		User::Leave(err);

		}

	CleanupClosePushL(file);

	ParseL(file);

	CleanupStack::PopAndDestroy(2, &fs);

	}

void CSifRefPkgParser::ParseL(RFile& aFileHandle)

	{

	// Read the file into the buffer 

	TInt fileSize = 0;

	User::LeaveIfError(aFileHandle.Size(fileSize));

	HBufC8* buffer = HBufC8::NewLC(fileSize);

	TPtr8 bufPtr = buffer->Des();

	TInt err = aFileHandle.Read(bufPtr);

	if (err != KErrNone)

		{

		DEBUG_PRINTF2(_L8("Failed to read reference package file with err %d"), err);

		User::LeaveIfError(err);

		}

	// Iterate over the lines

	TPtrC8 lines(*buffer);

	const TInt crlfLen = TPtrC8(KTxtCRLF).Size();

	while (lines.Size() > 0)

		{

		// Find next line

		TPtrC8 line;

		const TInt crlfPos = lines.Find(KTxtCRLF);

		if (crlfPos != KErrNotFound)

			{

			line.Set(lines.Left(crlfPos));

			lines.Set(lines.Mid(crlfPos+crlfLen));

			}

		else

			{

			if (lines.Size() > 0)

				{

				line.Set(lines);

				lines.Set(TPtrC8());

				}

			}

		// Split the line into a pair of the name of a tag and its value

		TPtrC8 name, value;

		SplitLineL(line, name, value);

		// Hand over the pair to recognition

		LineHandlerL(name, value);

		}

	CleanupStack::PopAndDestroy(buffer);

	// Check whether the file we have just parsed wasn't corrupted

	CheckInvariantL();

	}

void CSifRefPkgParser::LineHandlerL(const TPtrC8& aName, const TPtrC8& aValue)

	{

	if (aName == KTxtLanguages)

		{

		if (iLanguages.Count() > 0)

			{

			DEBUG_PRINTF(_L8("Multiple definition of languages"));

			User::Leave(KErrCorrupt);

			}

		RCHBufCArray languages;

		CleanupClosePushL(languages);

		SplitValuesL(aValue, languages);

		const TInt count = languages.Count();

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

			{

			iLanguages.AppendL(LanguageMapL(*languages[i]));

			}

		CleanupStack::PopAndDestroy(&languages);

		}

	else if (aName == KTxtComponentName)

		{

		if (iComponentNames.Count() > 0)

			{

			DEBUG_PRINTF(_L8("Multiple definition of Component Name"));

			User::Leave(KErrCorrupt);

			}

		SplitValuesL(aValue, iComponentNames);

		}

	else if (aName == KTxtComponentVendor)

		{

		if (iVendorNames.Count() > 0)

			{

			DEBUG_PRINTF(_L8("Multiple definition of Component Vendor"));

			User::Leave(KErrCorrupt);

			}

		SplitValuesL(aValue, iVendorNames);

		}

	else if (aName == KTxtComponentVersion)

		{

		ParseComponentVersionL(aValue, iVersion);

		}

	else if (aName == KTxtFile)

		{

		HBufC* file = HBufC::NewLC(aValue.Size());

		TPtr fileBuf = file->Des();

		fileBuf.Copy(aValue);

		fileBuf.Trim();

		iFiles.AppendL(file);

		CleanupStack::Pop(file);

		}

	else

		{

		DEBUG_PRINTF2(_L8("Failed due to unrecognized token: %S"), &aName);

		User::Leave(KErrCorrupt);

		}

	}

TInt CSifRefPkgParser::GetLanguageIndex(TLanguage aLanguage) const

	{

	const TInt count = iLanguages.Count();

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

		{

		if (iLanguages[i] == aLanguage)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

void CSifRefPkgParser::CheckInvariantL() const

	{

	if (iVersion.iMajor == 0 && iVersion.iMinor == 0 && iVersion.iBuild == 0)

		{

		DEBUG_PRINTF(_L8("Version not specified!"));

		User::Leave(KErrCorrupt);

		}

	if (iLanguages.Count() == 0)

		{

		DEBUG_PRINTF(_L8("Language not specified!"));

		User::Leave(KErrCorrupt);

		}

	if (iLanguages.Count() != iComponentNames.Count())

		{

		DEBUG_PRINTF(_L8("The number of languages and component names don't match!"));

		User::Leave(KErrCorrupt);

		}

	if (iLanguages.Count() != iVendorNames.Count())

		{

		DEBUG_PRINTF(_L8("The number of languages and vendor names don't match!"));

		User::Leave(KErrCorrupt);

		}

	}