/*

 * 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 "MemSpyCommandLine.h"

// System includes

#include <bacline.h>

#include <bautils.h>

#include <memspyengineclientinterface.h>

#include <memspysession.h>

#include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>

// User includes

#include "MemSpyCommands.h"

/*

 CMemSpyCommandLine::CMemSpyCommandLine()

 {	

 }

 */

CMemSpyCommandLine::CMemSpyCommandLine( CConsoleBase& aConsole )

	 :CActive(EPriorityHigh), iConsole(aConsole)

	{

	CActiveScheduler::Add(this);

	}

CMemSpyCommandLine::~CMemSpyCommandLine()

	{

	Cancel();

	if (iMemSpySession)

		{

		iMemSpySession->Close();

		}

	delete iMemSpySession;

	iFsSession.Close();

	}

void CMemSpyCommandLine::ConstructL()

	{

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

	iMemSpySession = new (ELeave) RMemSpySession();

	ConnectToMemSpyL();

	}

CMemSpyCommandLine* CMemSpyCommandLine::NewLC(CConsoleBase& aConsole)

	{

	CMemSpyCommandLine* self = new (ELeave) CMemSpyCommandLine(aConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CMemSpyCommandLine::PerformOpL(const CCommandLineArguments& aCommandLine)

	{

	const TInt count = aCommandLine.Count();

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::PerformOpL() - START - arg count: %d, this: 0x%08x", count, this ) );

		{

		// Get main command

		TBuf<KMemSpyCommandLineMaxLength> command;

		command.Copy(aCommandLine.Arg(1));

		command.UpperCase();

		// Extract arguments into array

		CDesCArrayFlat* args = new (ELeave) CDesCArrayFlat(4);

		CleanupStack::PushL(args);

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

			{

			args->AppendL(aCommandLine.Arg(i));

			}

		// Perform op

		PerformSingleOpL(command, *args);

		// Tidy up

		CleanupStack::PopAndDestroy(args);

		}

	else

		{

		User::Leave(KErrUnderflow);

		}

	}

void CMemSpyCommandLine::PerformSingleOpL(const TDesC& aCommand, const CDesCArray& aParameters)

	{

	// Record duration

	TTime timeStart;

	timeStart.HomeTime();

	const TInt paramCount = aParameters.Count();

#ifdef _DEBUG

	TRACE( RDebug::Print( _L("[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - START - command: %S, paramCount: %d, this: 0x%08x"), &aCommand, paramCount, this ) );

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

		{

		const TPtrC pParam(aParameters[i]);

		TRACE( RDebug::Print( _L("[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - param[%02d] = [%S]"), i, &pParam ) );

		}

#else

	RDebug::Print( _L("[MemSpyCmdLine] COMMAND: [%S] {%02d}..."), &aCommand, paramCount );

#endif

	TFileName batchFile;

	batchFile.Append(aCommand);

	TInt err = KErrNotSupported;

	TInt error = KErrNotSupported;

	// --- HELP

	if ( aCommand.CompareF( KMemSpyCmdHelp1) == 0 || 

		aCommand.CompareF(KMemSpyCmdHelp2) == 0 || 

		aCommand.CompareF(KMemSpyCmdHelp3) == 0 || 

		aCommand.CompareF(KMemSpyCmdHelp4) == 0)

		{

		iConsole.Write(KHelpMessage);

		iConsole.Write(KMemSpyCLINewLine);

		iConsole.Write(KHelpOutputCommand);

		iConsole.Write(KHelpOutputToFileCommand);

		iConsole.Write(KHelpHeapDumpCommand);

		iConsole.Write(KHelpSwmtCommand);

		iConsole.Write(KHelpKillServerCommand);

		iConsole.Write(KMemSpyCLINewLine);

		iConsole.Write(KHelpCommand);

		// Show input prompt.

		iCommandPromptPos = iConsole.CursorPos();

		RedrawInputPrompt();

		WaitForInput();

		CActiveScheduler::Start();

		}

	// --- OUTPUT

	//TODO: directory option to be added

	else if (aCommand.CompareF(KMemSpyCmdOutput) == 0) //change output mode   

		{

		if (paramCount >= 1)

			{

			if (aParameters[0].CompareF(KMemSpyCmdOutputParameterFile) == 0)

				{

				if (paramCount == 2)

					{

					TBuf<KMaxFileName> directory;

					directory.Copy(aParameters[1]);

					iMemSpySession->SwitchOutputToFileL(directory);

					}

				else

					{

					iMemSpySession->SwitchOutputToFileL(KNullDesC);

					}

				}

			else if( aParameters[0].CompareF( KMemSpyCmdOutputParameterTrace ) == 0)

				{

				TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - this: 0x%08x - Output Trace", this ) );

				iMemSpySession->SwitchOutputToTraceL();

				}

			}

		}

	// --- HEAP DUMP    

	else if (aCommand.CompareF(KMemSpyCmdHeapDump) == 0)

		{

		RedrawStatusMessage(KHeapDumpMessage);

		if (paramCount == 0) // no parameter - dump all heap data + kernel heap at the end

			{

			TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - this: 0x%08x - Heap_Dump (all threads)", this ) );

			// Dump heap data for all threads - Thread agnostic operation					

			iMemSpySession->OutputHeapData();

			// Dump kernel heap data

			iMemSpySession->OutputThreadHeapDataL( KMemSpyClientServerThreadIdKernel );					

			}

		else if (paramCount >= 1)

			{

			if (aParameters[0].CompareF(KMemSpyCmdHeapDumpParameterAll) == 0)

				{

				iMemSpySession->OutputHeapData();

				iMemSpySession->OutputThreadHeapDataL( KMemSpyClientServerThreadIdKernel );				

				}

			else if( aParameters[0].CompareF( KMemSpyCmdHeapDumpParameterKernel ) == 0 )

				{

				TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - this: 0x%08x - Heap_DumpKernel", this ) );

				iMemSpySession->OutputThreadHeapDataL( KMemSpyClientServerThreadIdKernel );				

				}

			else

				{

				// Dump heap data for named thread - filter

				const TPtrC pThreadName(aParameters[0]);

				TRACE( RDebug::Print( _L("[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - this: 0x%08x - Heap_Dump (%S)"), this, &pThreadName ) );

				iMemSpySession->OutputThreadHeapDataL(pThreadName);

				}

			}

		}

	// --- SYSTEM WIDE MEMORY TRACKING    

	else if (aCommand.CompareF(KMemSpyCmdSwmt) == 0)

		{

		RedrawStatusMessage(KSWMTMessage);

		TInt categories(0);

		TName threadNameFilter;

		if (paramCount == 0) //default state -> "dumpnow" command with "all" categories

			{

			TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - this: 0x%08x - dumpnow command", this ) );

			TInt category = TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryAll;

			iMemSpySession->SetSwmtCategoriesL(category);

			iMemSpySession->ForceSwmtUpdateL();

			}

		else if (paramCount >= 1)

			{

			const TPtrC pParam(aParameters[0]);

			if (pParam.CompareF(KMemSpyCmdSwmtParameterStarttimer) == 0) // "starttimer" - start tracking

				{

				TInt result(0);

				categories = TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryAll;

				iMemSpySession->SetSwmtTimerIntervalL(KMemSpySysMemTrackerConfigMinTimerPeriod);

				if (paramCount >= 2) // user gave some optional parameters - <categories> or <value in seconds>

					{

					TLex lex(aParameters[1]);

					if (lex.Val(result) == KErrNone) //if 2nd parameter is not number, then parse parameters

						{

						if( result >= KMemSpySysMemTrackerConfigMinTimerPeriod && result <= KMemSpySysMemTrackerConfigMaxTimerPeriod )

							{

							iMemSpySession->SetSwmtTimerIntervalL( result );							

							}

						}

					TRAP( err, ParseSWMTParametersL( aParameters, categories, threadNameFilter) );

					}

				//if( !err )

				//	{

				/*

				 _LIT( KPressS, "Press 's' to stop the timer " );

				 iConsole.Write( KPressS );

				 iCommandPromptPos = iConsole.CursorPos();					

				 RedrawInputPrompt();					

				 WaitForInput();

				 */

				iMemSpySession->StartSwmtTimerL();

				//CActiveScheduler::Start();									

				//	}	

				}

			else if (pParam.CompareF(KMemSpyCmdSwmtParameterStoptimer) == 0) // "stoptime" - stop tracking

				{

				iMemSpySession->StopSwmtTimerL();

				}

			else if (pParam.CompareF(KMemSpyCmdSwmtParameterDumpnow) == 0) // "dumpnow" - runs one tracking cycle (CmdSWMT_ForceUpdate before)

				{

				categories = TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryAll;

				if (paramCount >= 2) // user gave some optional parameters - <categories>

					{

					TRAP( err, ParseSWMTParametersL( aParameters, categories, threadNameFilter) );

					}

				if (!err)

					{

					iMemSpySession->SetSwmtCategoriesL(categories);

					iMemSpySession->ForceSwmtUpdateL();

					}

				}

			else //no parameters ("starttimer / stoptimer / dumpnow"), just categories / thread filter

			//so dumpnow is used as default with category / thread specified

				{

				TRAP( err, ParseSWMTParametersL( aParameters, categories, threadNameFilter) );

				if (!err)

					{

					iMemSpySession->SetSwmtCategoriesL(categories);

					if (threadNameFilter.Length() > 0)

						{

						iMemSpySession->SetSwmtFilter(threadNameFilter);

						}

					}

				iMemSpySession->ForceSwmtUpdateL();

				}

			}

		}

	// --- KILL SERVER

	else if (aCommand.CompareF(KMemSpyCmdKillServer) == 0)

		{

		}

	// RedrawStatusMessage();   

	TRACE( RDebug::Print( _L("[MemSpyCmdLine] CMemSpyCommandLine::PerformSingleOpL() - END - err: %d, this: 0x%08x, cmd: %S" ), err, this, &aCommand ) );

	// Calculate duration

	TTime timeEnd;

	timeEnd.HomeTime();

	TTimeIntervalSeconds interval(0);

	timeEnd.SecondsFrom(timeStart, interval);

	// Print some info

	if (err != KErrNone)

		{

		RDebug::Print( _L("[MemSpyCmdLine] COMMAND: [%S] {%02d} {%08d sec} => ERROR: %d"), &aCommand, paramCount, interval.Int(), err );

		}

	else

		{

		RDebug::Print( _L("[MemSpyCmdLine] COMMAND: [%S] {%02d} {%08d sec} => OK"), &aCommand, paramCount, interval.Int() );

		}

	// Spacer

	RDebug::Printf(" ");

	}

void CMemSpyCommandLine::ConnectToMemSpyL()

	{

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ConnectToMemSpyL() - START - this: 0x%08x", this ) );

	TInt err = iMemSpySession->Connect();

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ConnectToMemSpyL() - connect #1 err: %d, this: 0x%08x", err, this ) );

	if (err == KErrNotFound)

		{

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ConnectToMemSpyL() - launching MemSpy... - this: 0x%08x", this ) );

		LaunchMemSpyL();

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ConnectToMemSpyL() - launched MemSpy - this: 0x%08x", this ) );

		err = iMemSpy->Connect();

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ConnectToMemSpyL() - connect #2 err: %d, this: 0x%08x", err, this ) );

		}

	User::LeaveIfError(err);

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ConnectToMemSpyL() - END - ok - this: 0x%08x", this ) );

	}

void CMemSpyCommandLine::LaunchMemSpyL()

	{

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - START - this: 0x%08x", this ) );

	TInt err = KErrGeneral;

	RProcess proc;

	// Try to run server first

	err = proc.Create(KMemSpyProcessName0, KNullDesC);

	if (err == KErrNone)

		{

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - Create server process successfully... - this: 0x%08x", this ) );

		TRequestStatus status;

		proc.Rendezvous(status);

		proc.Resume();

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - MemSpy resumed, waiting for Rendezvous... - this: 0x%08x", this ) );

		User::WaitForRequest(status);

		err = status.Int();

		proc.Close();

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - Rendezvous complete: %d, this: 0x%08x", err, this ) );

		}

	// If server is not available, try with s60 UI

	if (err != KErrNone)

		{

		err = proc.Create(KMemSpyProcessName1, KNullDesC);

		if (err == KErrNone)

			{

			TFullName fullName;

			proc.FullName(fullName);

			TRACE( RDebug::Print( _L("[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - Create S60 UI process successfully... - this: 0x%08x, name: %S"), this, &fullName ) );

			TRequestStatus status;

			proc.Rendezvous(status);

			proc.Resume();

			TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - MemSpy resumed, waiting for Rendezvous... - this: 0x%08x", this ) );

			User::WaitForRequest(status);

			err = status.Int();

			proc.Close();

			TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - Rendezvous complete: %d, this: 0x%08x", err, this ) );

			}

		}

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - final error: %d, this: 0x%08x", err, this ) );

	User::LeaveIfError(err);

	User::After(10 * 1000000);

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::LaunchMemSpyL() - END - ok - this: 0x%08x", this ) );

	}

CDesCArray* CMemSpyCommandLine::ReadLinesL(RFile& aFile)

	{

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - START - this: 0x%08x", this ) );

	CDesCArrayFlat* lines = new (ELeave) CDesCArrayFlat(10);

	CleanupStack::PushL(lines);

	TInt size = 0;

	User::LeaveIfError(aFile.Size(size));

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - this: 0x%08x, file size: %d", this, size ) );

	// Read file

	HBufC8* narrowBuf = HBufC8::NewLC(size);

	TPtr8 pBufNarrow(narrowBuf->Des());

	TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - this: 0x%08x, reading file..." ) );

	User::LeaveIfError(aFile.Read(pBufNarrow));

	if (pBufNarrow.Length() <= 2)

		{

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - this: 0x%08x - BAD FILE LENGTH", this ) );

		User::Leave(KErrCorrupt);

		}

	// Look for BOM and convert to unicode

	HBufC* unicodeText = HBufC::NewL(size);

	TPtr pUnicodeText(unicodeText->Des());

	if (pBufNarrow[0] == 0xFF && pBufNarrow[1] == 0xFE)

		{

		// It's unicode... and we don't want the BOM, hence -2

		const TInt textLength = size - 2;

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - this: 0x%08x - UNICODE TEXT - textLength: %d", this, textLength / 2 ) );

		Mem::Copy( (TUint8 *)pUnicodeText.Ptr(), pBufNarrow.Ptr() + 2, textLength );

		pUnicodeText.SetLength(textLength / 2);

		}

	else

		{

		// It's ASCII, convert it to unicode...

		TRACE( RDebug::Printf( "[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - this: 0x%08x - ASCII TEXT - textLength: %d", this, size ) );

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

			{

			pUnicodeText.Append(pBufNarrow[i]);

			}

		}

	// Discard old narrow text

	CleanupStack::PopAndDestroy(narrowBuf);

	CleanupStack::PushL(unicodeText);

	// Try to extract lines of text...

	HBufC* line = HBufC::NewLC(1024);

	TPtr pLine(line->Des());

	const TInt length = unicodeText->Length();

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

		{

		const TChar c(pUnicodeText[i]);

		//

		if (c == '\r' || c == '\n')

			{

			pLine.Trim();

			if (pLine.Length())

				{

				TRACE( RDebug::Print( _L("[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - this: 0x%08x - LINE[%03d] %S"), this, lines->Count(), line ) );

				lines->AppendL(pLine);

				}

			pLine.Zero();

			}

		else

			{

			pLine.Append(c);

			}

		}

	// Save last line, just in cae it didn't end with a CR/LF

	pLine.Trim();

	if (pLine.Length())

		{

		TRACE( RDebug::Print( _L("[MemSpyCmdLine] CMemSpyCommandLine::ReadLinesL() - this: 0x%08x - LINE[%03d] %S"), this, lines->Count(), line ) );

		lines->AppendL(pLine);

		}

	CleanupStack::PopAndDestroy(2, unicodeText); // line & unicodeText