// Copyright (c) 2007-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 "TestScripts.h"

#include "httptestutils.h"

EXPORT_C CScriptFile* CScriptFile::NewL(CHTTPTestUtils& aTestUtils, const TDesC& aComponent, const TDesC& aScript)

	{

	CScriptFile* self = NewLC(aTestUtils, aComponent, aScript);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CScriptFile* CScriptFile::NewLC(CHTTPTestUtils& aTestUtils, const TDesC& aComponent, const TDesC& aScript)

	{

	CScriptFile* self = NewLC(aTestUtils, aComponent);

	self->ReadScriptL(aScript);

	return self;

	}

EXPORT_C CScriptFile* CScriptFile::NewL(CHTTPTestUtils& aTestUtils, const TDesC& aComponent)

	{

	CScriptFile* self = NewLC(aTestUtils, aComponent);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CScriptFile* CScriptFile::NewLC(CHTTPTestUtils& aTestUtils, const TDesC& aComponent)

	{

	CScriptFile* self = new (ELeave) CScriptFile(aTestUtils);

	CleanupStack::PushL(self);

	self->ConstructL(aComponent);

	return self;

	}

void CScriptFile::ConstructL(const TDesC& aComponent)

	{

	iSections = new (ELeave) CArrayPtrFlat<CScriptSection>(10);

	iComponent = aComponent.AllocL();

	}

CScriptFile::CScriptFile(CHTTPTestUtils& aTestUtils)

: iTestUtils(aTestUtils)

	{

	}

EXPORT_C CScriptFile::~CScriptFile()

	{

	if (iSections)

		{

		iSections->ResetAndDestroy();

		delete iSections;

		}

	delete iComponent;

	}

CScriptSection* CScriptFile::Section(const TDesC& aSectionName)

	{

	CScriptSection* section = iLastSection;

	if (!iLastSection || iLastSection->SectionName().CompareF(aSectionName) != 0)

		{

		const TInt count = iSections->Count();

		for (TInt i = 0; i < count; i++) //order important

			{

			section = iSections->At(i);

			iLastSection = section;

			if (iLastSection->SectionName().CompareF(aSectionName) == 0)

				{

				break;

				}

			else

				{

				section = NULL;

				}

			}

		}

	return section;

	}

EXPORT_C const TDesC& CScriptFile::ItemValue(const TDesC& aSection, const TDesC& aItem, const TDesC& aDefault)

	{

	CScriptSection* section = Section(aSection);

	if (section != NULL)

		return section->ItemValue(aItem, aDefault);

	return aDefault;

	}

EXPORT_C TInt CScriptFile::ItemValue(const TDesC& aSection, const TDesC& aItem, const TInt aDefault)

	{

	TInt output = aDefault;

	CScriptSection* section = Section(aSection);

	if (section != NULL)

		{

		output = section->ItemValue(aItem, aDefault);

		}

	return output;

	}

EXPORT_C HBufC* CScriptFile::ItemValueLC(CHTTPTestUtils& aTestUtils, const TDesC& aComponent, const TDesC& aScript, const TDesC& aSection, const TDesC& aItem, const TDesC& aDefault)

	{

	CScriptFile* self = NewLC(aTestUtils, aComponent, aScript);

	TPtrC output(self->ItemValue(aSection, aItem, aDefault));

	HBufC* buf = output.AllocL();

	CleanupStack::PopAndDestroy(self);

	CleanupStack::PushL(buf);

	return buf;

	}

EXPORT_C TInt CScriptFile::ItemValueL(CHTTPTestUtils& aTestUtils, const TDesC& aComponent, const TDesC& aScript, const TDesC& aSection, const TDesC& aItem, const TInt aDefault)

	{

	CScriptFile* self = NewLC(aTestUtils, aComponent, aScript);

	TInt output = self->ItemValue(aSection, aItem, aDefault);

	CleanupStack::PopAndDestroy(self);

	return output;

	}

HBufC8* CScriptFile::ReadFileL(const TDesC& aFile) const

	{

	HBufC8* ret = iTestUtils.ReadFileLC(aFile);

	CleanupStack::Pop(ret);

	return ret;

	}

HBufC* CScriptFile::ReadFileLC(const TDesC& aScript) const

	{

	HBufC8* file = NULL;

	TRAPD(err, file = ReadFileL(aScript));

	if (err)

		{

		TParse fileOut;

		err = iTestUtils.ResolveFile(*iComponent, aScript, fileOut);

		if (err)

			{

			iTestUtils.Test().Printf(_L("Cannot read file %S. Error=%d"), &aScript, err);

			User::Leave(err);

			}

		file = ReadFileL(fileOut.FullName());

		}

	CleanupStack::PushL(file);

	HBufC* buf = HBufC::NewL(file->Length());

	buf->Des().Copy(*file);

	CleanupStack::PopAndDestroy(file);

	CleanupStack::PushL(buf);

	return buf;

	}

EXPORT_C void CScriptFile::ReadScriptL(const TDesC& aScript)

	{

	iSections->ResetAndDestroy();

	ParseScriptSectionsL(aScript, KErrNotFound);

	}

void CScriptFile::ParseEmbeddedScriptsL(CScriptSection& aSection, TInt aInsertIndex)

	{

	// This must be a Script section

	__ASSERT_DEBUG(aSection.SectionName().CompareF(KScriptsSection)==0, User::Invariant());

	// Loop through the script section and load and parse each script file in reverse

	// order so that the sections are inserted in the correct order

	TInt scriptCount = aSection.Items().Count();

	for(TInt ii=scriptCount-1; ii>=0; --ii)

		{

		CScriptSectionItem& item = aSection.Item(ii);

		// Sometimes comments are included as part of the value. We need to include

		// some simple parsing here to extract just the filename from the value

		// by just including the text upto a '\n' or ' ' characters.

		TPtrC fileName(item.Value());

		TInt locateWhiteSpace = fileName.LocateF('\n');

		if(locateWhiteSpace>0)

			fileName.Set(fileName.Left(locateWhiteSpace));

		locateWhiteSpace = fileName.LocateF(' ');

		if(locateWhiteSpace>0)

		fileName.Set(fileName.Left(locateWhiteSpace));

		ParseScriptSectionsL(fileName, aInsertIndex);

		}

	}

void CScriptFile::ParseScriptSectionsL(const TDesC& aScript, TInt aInsertIndex)

	{

	iLastSection = NULL;

	CScriptSection* section = NULL;

	CScriptSectionItem* currentItem = NULL;

	TInt currentItemStart = 0;

	CScriptSection* sectionAll = NULL;

	RArray<TInt> sectionIndexArray;

	CleanupClosePushL(sectionIndexArray);

	TInt indexIncrement = 0;		

	HBufC* scriptContents = ReadFileLC(aScript);

	TLex input(*scriptContents);

	while (!input.Eos())

		{

	    input.SkipSpaceAndMark();

		input.SkipCharacters();

		if ( input.TokenLength() == 0 )    // if valid potential token

			{

			break;

			}

		TPtrC token = input.MarkedToken();

		if (token.CompareF(_L("endscript")) == 0)

			{

			break;

			}

		else if (token.FindF(KScriptSectionStart) == 0 && token.Length() > 2)

			{

			ParseAndSetItemValueL(*scriptContents, input, currentItemStart, currentItem);

			TInt mid = 1;

			TInt len = token.Length() - 2;

			if (sectionAll)

				section = CScriptSection::NewLC(token.Mid(mid, len), *sectionAll);

			else

				section = CScriptSection::NewLC(token.Mid(mid, len));

			if (!sectionAll && section->SectionName().CompareF(_L("All")) == 0)

				sectionAll = section;

			// We have a Scripts section, store its index as we need to track where

			// it occured so that the scripts can be added in the same location

			// after the current file has parsed

			if (section->SectionName().CompareF(KScriptsSection) == 0)

				{

				if(aInsertIndex==KErrNotFound)

					{

					// Not an embedded script, simple store its index

					TInt currectSectionsCount = iSections->Count();

					sectionIndexArray.Append(currectSectionsCount);

					}

				else

					{

					// An embedded script, calculate the index it should be inserted at

					TInt currectSectionsCount = indexIncrement+aInsertIndex;

					sectionIndexArray.Append(currectSectionsCount);

					}

				}

			// Check if the section needs to be inserted at a particular location

			if(aInsertIndex==KErrNotFound)

				iSections->AppendL(section);

			else

				iSections->InsertL(aInsertIndex + indexIncrement++, section);

			CleanupStack::Pop(section);

			}

		else if (section)

			{

			TPtrC itemEnd(KScriptItemEnd);

			if (itemEnd.Length() < token.Length() && token.Right(itemEnd.Length()).CompareF(itemEnd) == 0)

				{

				FoundNewItemL(*scriptContents, input, currentItemStart, *section, currentItem);

				}

			}

		}

	ParseAndSetItemValueL(*scriptContents, input, currentItemStart, currentItem);

	CleanupStack::PopAndDestroy(scriptContents);

	// We have been tracking where the script sections have been inserted so we

	// want to load the sections from the embedded script file and insert them

	// at the same point. This must be done in reverse order so that the index

	// values of script sections before the current one is maintained.

	TInt scriptSectionsCount = sectionIndexArray.Count();

	for( TInt ii=scriptSectionsCount-1; ii>=0; --ii)

		{

		TInt indexOfScriptSection = sectionIndexArray[ii];

		ParseEmbeddedScriptsL(*(iSections->At(indexOfScriptSection)), indexOfScriptSection);

		}

	CleanupStack::PopAndDestroy(&sectionIndexArray);

	}

TPtrC CScriptFile::ParseValue(const TDesC& aText, const TLex& aInput, TInt aCurrentItemStart) const

	{

	TInt mid = aCurrentItemStart;

	TInt len = aInput.MarkedOffset() - mid;

	TPtrC ret(KNullDesC);

	if (len > 0)

		ret.Set(aText.Mid(mid, len));

	return ret;

	}

void CScriptFile::ParseAndSetItemValueL(const TDesC& aText, const TLex& aInput, TInt aCurrentItemStart, CScriptSectionItem*& arCurrentItem)

	{

	if (arCurrentItem)

		{

		delete arCurrentItem->iValue;

		arCurrentItem->iValue = NULL;

		arCurrentItem->iValue = ParseValue(aText, aInput, aCurrentItemStart).AllocL();

		arCurrentItem->iValue->Des().Trim();

		ReplaceL(KScriptCRLF, KScriptLF, arCurrentItem->iValue);

		if (arCurrentItem->Item().CompareF(KDefaults) == 0)

			{

			CopyInDefaultsL(arCurrentItem->iParent, arCurrentItem->Value());

			}

		}

	arCurrentItem = NULL;

	}

void CScriptFile::FoundNewItemL(const TDesC& aText, TLex& arInput, TInt& arCurrentItemStart, CScriptSection& aSection, CScriptSectionItem*& arCurrentItem)

	{

	TPtrC token = arInput.MarkedToken();

	ParseAndSetItemValueL(aText, arInput, arCurrentItemStart, arCurrentItem);

	arInput.SkipSpaceAndMark();

	arCurrentItemStart = arInput.Offset();

	TPtrC itemEnd(KScriptItemEnd);

	const TInt length = token.Length() - itemEnd.Length();

	arCurrentItem = &aSection.ReplaceItemL(token.Left(length), KNullDesC);

	}

void CScriptFile::CopyInDefaultsL(CScriptSection& aSection, const TDesC& aDefaultFile)

	{

	CScriptFile* file = CScriptFile::NewLC(iTestUtils, *iComponent, aDefaultFile);

	TInt count = file->Sections().Count();

	if (count > 0)

		{

		CScriptSection& def = *file->Sections()[0];

		aSection.SetDefaultsL(def);

		}

	CleanupStack::PopAndDestroy(file);

	}

EXPORT_C TInt CScriptFile::GetNextWord(TLex& aInput, TChar aDelimiter, TInt& aOutput)

	{

	aOutput = 0;

	TPtrC string;

	TInt err = GetNextWord(aInput, aDelimiter, string);

	if (!err)

		{

		TLex number(string);

		err = number.Val(aOutput);

		}

	return err;

	}

EXPORT_C TInt CScriptFile::GetNextWord(TLex& aInput, TChar aDelimiter, TPtrC& aOutput)

	{

	//Get to the start of the descriptor

	while (!aInput.Peek().IsAlphaDigit() && aInput.Peek() != '+' && !aInput.Eos() && aInput.Peek() != aDelimiter)

		aInput.Inc();

	if (aInput.Eos())

		return KErrNotFound;

	aInput.Mark();

	while (aInput.Peek() != aDelimiter && !aInput.Eos())

		aInput.Inc();

	aOutput.Set(aInput.MarkedToken());

	if (!aInput.Eos())

		aInput.SkipAndMark(1);

	return KErrNone;

	}

EXPORT_C void CScriptFile::ReplaceL(const TDesC& aOld, const TDesC& aNew, HBufC*& rString)

	{

	HBufC* repl = ReplaceLC(aOld, aNew, *rString);

	CleanupStack::Pop(repl);

	delete rString;

	rString = repl;

	}

EXPORT_C HBufC* CScriptFile::ReplaceLC(const TDesC& aOld, const TDesC& aNew, const TDesC& aOldString)

	{

	HBufC* rString = aOldString.AllocLC();

	TInt oldLen = aOld.Length();

	TInt newLen = aNew.Length();

	if (!oldLen)

		return rString;

	for (TInt pos = 0; pos < rString->Length(); pos += newLen)

		{

		TPtrC ptrC = rString->Mid(pos);

		TInt find = ptrC.Find(aOld);

		if (find == KErrNotFound)

			return rString;

		pos += find;

		if (newLen > oldLen)

			{

			rString = rString->ReAllocL(rString->Length() + newLen - oldLen);

			CleanupStack::Pop();

			CleanupStack::PushL(rString);

			}

		TPtr ptr(rString->Des());

		ptr.Replace(pos, oldLen, aNew);

		}

	return rString;

	}