/*
* Copyright (c) 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 <e32base.h>
#include <e32std.h>
#include <e32cons.h>			// Console
#include <e32debug.h>
#include <multimedia/omx_xml_script.h>

//  Constants

_LIT(KTextConsoleTitle, "Console");
_LIT(KTextFailed, " failed, leave code = %d");
_LIT(KTextPressAnyKey, " [press any key]\n");

//  Global Variables

LOCAL_D CConsoleBase* console; // write all messages to this


//  Local Functions

/**
 * Logs script output to console and RDebug.
 */
class TConsoleLogger : public MOmxScriptTestLogger
	{
	void Log(const TText8* aFile, TInt aLine, TOmxScriptSeverity /*aSeverity*/, const TDes& aMessage)
		{
		TPtrC8 fileDes8(aFile);
		TBuf<255> fileDes;
		fileDes.Copy(fileDes8);
		console->Printf(_L("%S:%d %S\n"), &fileDes, aLine, &aMessage);
		RDebug::Print(_L("%S:%d %S"), &fileDes, aLine, &aMessage);
		}
	};

LOCAL_C void ShowUsage()
	{
	console->Write(_L("Usage: omxscript <filename> <section>\n"));
	}

LOCAL_C TInt ParseSize(const TDesC& aDes)
	{
	TLex lex(aDes);
	TInt val;
	if(lex.Val(val) != KErrNone || val < 0)
		{
		return KErrArgument;
		}
	switch(lex.Get())
		{
	case 0:	// no modifier
		break;
	case 'K':
		val <<= 10;
		break;
	case 'M':
		val <<= 20;
		break;
	default:	// bad modifier
		return KErrArgument;
		}
	if(lex.Get() != 0)
		{
		// trailing text
		return KErrArgument;
		}
	return val;
	}

/**
 * Extracts parameters from the command line.
 * This method must not use the cleanup stack; there may not be one allocated since we may be switching heaps.
 */
LOCAL_C TInt ParseCommandLineArgs(TDes& commandLine, TPtrC& aFilename, TPtrC& aSection, TInt &aHeapSize)
	{
	// copy the command line
	if(User::CommandLineLength() > commandLine.MaxLength())
		{
		return KErrTooBig;
		}
	User::CommandLine(commandLine);
	
	// parse filename, section and other args from the command line
	TInt heapSize = KErrNotFound;
	TPtrC filename(KNullDesC);
	TPtrC section(KNullDesC);
	TLex lex(commandLine);
	lex.SkipSpaceAndMark();
	while(!lex.Eos())
		{
		lex.SkipCharacters();
		TPtrC arg = lex.MarkedToken();
		lex.SkipSpaceAndMark();
		if(arg == _L("-heap"))
			{
			if(lex.Eos())
				{
				// no param following
				return KErrArgument;
				}
			lex.SkipCharacters();
			TPtrC heapArg = lex.MarkedToken();
			lex.SkipSpaceAndMark();
			heapSize = ParseSize(heapArg);
			if(heapSize == KErrArgument)
				{
				return KErrArgument;
				}
			}
		else if(filename.Length() == 0)
			{
			filename.Set(arg);
			}
		else if(section.Length() == 0)
			{
			section.Set(arg);
			}
		else
			{
			// to many unnamed params
			return KErrArgument;
			}
		}
	if(section.Length() == 0)
		{
		return KErrArgument;
		}
	aHeapSize = heapSize;
	aFilename.Set(filename);
	aSection.Set(section);
	return KErrNone;
	}

LOCAL_C void MainL()
	{
	RBuf commandLine;
	commandLine.CreateL(User::CommandLineLength());
	CleanupClosePushL(commandLine);
	TPtrC filename(KNullDesC);
	TPtrC section(KNullDesC);
	TInt heapSize = KErrNotFound;
	TInt error = ParseCommandLineArgs(commandLine, filename, section, heapSize);
	if(error)
		{
		ShowUsage();
		User::Leave(error);
		}
	
	//logs script output to console and RDebug
	TConsoleLogger logger;
	
	COmxXmlScript* script = COmxXmlScript::NewL(logger);
	CleanupStack::PushL(script);
	script->RunScriptL(filename, section);
	CleanupStack::PopAndDestroy(2, &commandLine);
	}

LOCAL_C void DoStartL()
	{
	// Create active scheduler (to run active objects)
	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);

	MainL();

	// Delete active scheduler
	CleanupStack::PopAndDestroy(scheduler);
	}

/**
 * Invokes ParseCommandLineArgs() to retrieve any heap size specified on the command line.
 * The command line descriptor is allocated on the stack (since we are avoiding heap allocations at this point).
 * The descriptors are then thrown away (to avoid consuming too much stack space).
 * Later, the command line will be parsed again but on the heap.
 */
LOCAL_C TInt ParseHeapSize()
	{
	TInt heapSize = KErrNotFound;
	TPtrC filename(KNullDesC);
	TPtrC section(KNullDesC);
	TBuf<255> commandLine;
	// ignore error
	ParseCommandLineArgs(commandLine, filename, section, heapSize);
	return heapSize;
	}

//  Global Functions

GLDEF_C TInt E32Main()
	{
	

	TInt heapSize = ParseHeapSize();


	// switch heap if specified
	RHeap* oldHeap = NULL;
	RHeap* newHeap = NULL;

	if(heapSize != KErrNotFound)
		{
		const TInt KMinHeapGrowBy = 1;
		const TInt KByteAlignment = 0;
		const TBool KSingleThreaded = EFalse;
		newHeap = User::ChunkHeap(NULL, heapSize, heapSize, KMinHeapGrowBy, KByteAlignment, KSingleThreaded);
		if(newHeap == NULL)
			{
			return KErrNoMemory;
			}
		oldHeap = User::SwitchHeap(newHeap);		
		}

	// Create cleanup stack
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();

	// Create output console
	TRAPD(createError, console = Console::NewL(KTextConsoleTitle, TSize(KConsFullScreen,KConsFullScreen)));
	if (createError)
	return createError;
	
	// Run application code inside TRAP harness, wait keypress when terminated
	TRAPD(mainError, DoStartL());
	

	if(mainError)
		{
		console->Printf(KTextFailed, mainError);
		}
	console->Printf(KTextPressAnyKey);
	console->Getch();

	delete console;
	delete cleanup;
	__UHEAP_MARKEND;
	
	if(newHeap != NULL)
		{
		User::SwitchHeap(oldHeap);
		newHeap->Close();
		}

	return KErrNone;
	}