/*

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

// System includes

#include <e32debug.h>

// Engine includes

#include <memspyengineclientinterface.h>

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyenginehelperstack.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspydevicewideoperations.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyenginehelperkernelcontainers.h>

#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

// User includes

#include "ConsoleConstants.h"

#include "ConsoleDWOperation.h"

CMemSpyConsoleMenu::CMemSpyConsoleMenu( RMemSpySession& aSession, CConsoleBase& aConsole )

:   CActive( EPriorityHigh ), iSession( aSession ), iConsole( aConsole ), iOutputType(EOutputTypeDebug)

    {

    CActiveScheduler::Add( this );

    // TODO: iEngine.SetObserver( this );

    }

CMemSpyConsoleMenu::~CMemSpyConsoleMenu()

    {

    Cancel();

    }

void CMemSpyConsoleMenu::ConstructL()

    {

    DrawMenuL();

    WaitForInput();

    }

CMemSpyConsoleMenu* CMemSpyConsoleMenu::NewLC( RMemSpySession& aSession, CConsoleBase& aConsole )

    {

    CMemSpyConsoleMenu* self = new(ELeave) CMemSpyConsoleMenu( aSession, aConsole );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

void CMemSpyConsoleMenu::DrawMenuL()

    {

    iConsole.ClearScreen();

    // First line - sink type (defaults to file)

    _LIT( KLine1, "1 or T. Toggle output mode between file or trace [%S]" );

    if  ( iOutputType == EOutputTypeDebug )

        {

        _LIT( KLine1Trace, "Trace" );

        iConsole.Printf( KLine1, &KLine1Trace );

        }

    else

        {

        _LIT( KLine1File, "File" );

        iConsole.Printf( KLine1, &KLine1File );

        }

    iConsole.Write( KMemSpyConsoleNewLine );

    // Kernel heap dump

    _LIT( KLine2, "2 or K. Dump kernel heap data" );

    iConsole.Write( KLine2 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Kernel heap dump

    _LIT( KLine3, "3 or O. Dump kernel object listing" );

    iConsole.Write( KLine3 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Heap (CSV) listing

    _LIT( KLine4, "4 or H. Heap CSV-information (for all threads)" );

    iConsole.Write( KLine4 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Stack (CSV) listing

    _LIT( KLine5, "5 or S. Stack CSV-information (for all threads)" );

    iConsole.Write( KLine5 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Heap data

    _LIT( KLine6, "6 or D. Get heap data for a user-thread" );

    iConsole.Write( KLine6 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Heap cell listing

    _LIT( KLine7, "7 or L. Get heap cell list for a user-thread" );

    iConsole.Write( KLine7 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Exit key

    _LIT( KLine8, "8 or X. Exit" );

    iConsole.Write( KLine8 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Spacer

    iConsole.Write( KMemSpyConsoleNewLine );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Status message

    iStatusMessagePos = iConsole.CursorPos();

    RedrawStatusMessage();

    // Spacer

    iConsole.Write( KMemSpyConsoleNewLine );

    // Show input prompt.

    iCommandPromptPos = iConsole.CursorPos();

    RedrawInputPrompt();

    }

void CMemSpyConsoleMenu::WaitForInput()

    {

    ASSERT( !IsActive() );

    iConsole.Read( iStatus );

    SetActive();

    }

void CMemSpyConsoleMenu::RunL()

    {

    TKeyCode key = iConsole.KeyCode();

    //

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::RunL() - START - key = %d", key );

#endif

    //

    if  ( key == EKeyEnter || key == KMemSpyUiS60KeyCodeButtonOk || key == KMemSpyUiS60KeyCodeRockerEnter )

        {

        TRAP_IGNORE( ProcessCommandBufferL() );

        }

    else if ( key == EKeyEscape || key == KMemSpyUiS60KeyCodeButtonCancel )

        {

        ClearCommandBuffer();

        RedrawInputPrompt();

        }   

    else if ( key == EKeyBackspace )

        {

        const TInt cmdBufLength = iCommandBuffer.Length();

        if  ( cmdBufLength > 0 )

            {

            iCommandBuffer.SetLength( cmdBufLength - 1 );

            RedrawInputPrompt();

            }

        }

    else

        {

        TChar character( key );

        if  ( character.IsPrint() )

            {

            if  ( iCommandBuffer.Length() < iCommandBuffer.MaxLength() )

                {

                iCommandBuffer.Append( TChar( key ) );

                }

            RedrawInputPrompt();

            }

        }

    WaitForInput();

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::RunL() - END" );

#endif

    }

void CMemSpyConsoleMenu::DoCancel()

    {

    iConsole.ReadCancel();

    }

void CMemSpyConsoleMenu::OnCmdSinkTypeToggleL()

    {

	iOutputType = iOutputType == EOutputTypeFile ? EOutputTypeDebug : EOutputTypeFile;

    }

void CMemSpyConsoleMenu::OnCmdHeapDataKernelL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdHeapDataKernelL() - START" );

#endif

    _LIT( KMsg, "Ouputting Kernel data..." );

    RedrawStatusMessage( KMsg );

    iSession.OutputKernelHeapDataL( iOutputType );

    RedrawStatusMessage( KNullDesC );

    }

void CMemSpyConsoleMenu::OnCmdKernelObjectListingL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdKernelObjectListingL() - START" );

#endif

    _LIT( KMsg, "Ouputting Kernel Object listing..." );

    RedrawStatusMessage( KMsg );

    //

    iSession.OutputKernelObjectsL( iOutputType );

    RedrawStatusMessage( KNullDesC );

    }

void CMemSpyConsoleMenu::OnCmdCSVListingStackL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdCSVListingStackL() - START" );

#endif

    iSession.OutputCompactStackInfoL( iOutputType );

    }

void CMemSpyConsoleMenu::OnCmdCSVListingHeapL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdCSVListingHeapL() - START" );

#endif

    iSession.OutputCompactHeapInfoL( iOutputType );

    }

void CMemSpyConsoleMenu::OnCmdHeapDataUserL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdHeapDataUserL() - START" );

#endif

    GetProcessName();

    // Work out what to do.

    iCommandBuffer.Trim();

#ifdef _DEBUG

    RDebug::Print( _L("[MCon] CMemSpyConsoleMenu::OnCmdHeapDataUserL() - requested dump heap for proc: %S"), &iCommandBuffer );

#endif

    if  ( iCommandBuffer.Length() > 0 )

        {

        iConsole.Write( KMemSpyConsoleNewLine );

        iConsole.Write( KMemSpyConsoleNewLine );

        //

        HBufC* cmdBuf = HBufC::NewLC( KMemSpyMaxInputBufferLength + 10 );

        TPtr pCmdBuf( cmdBuf->Des() );

        pCmdBuf.Copy( iCommandBuffer );

        pCmdBuf.Append( KMemSpyConsoleWildcardCharacter );

        TInt err;

        TProcessId procId;

        TRAP(err, procId = iSession.GetProcessIdByNameL(pCmdBuf));

        //

        if (err == KErrNone) 

        	{

        	RArray<CMemSpyApiThread*> threads;

        	TRAP(err, iSession.GetThreadsL(procId, threads));

        	if (err == KErrNone)

        		{

				_LIT( KProcessingRequest, "** Dumping Heap Data for thread: %S" );     	

				TFullName fullThreadName;

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

                    {

                    CMemSpyApiThread* thread = threads[i];

                    //

                    fullThreadName = thread->Name();

                    iConsole.Printf( KProcessingRequest, &fullThreadName );

                    iConsole.Write( KMemSpyConsoleNewLine );

                    //

                    TRAP_IGNORE( iSession.OutputThreadHeapDataL(iOutputType, thread->Id()) );

                    delete thread;

                    }

                }

            }

        CleanupStack::PopAndDestroy( cmdBuf );

        DrawMenuL();

        }

    else

        {

        // Bad user data entry

        DrawMenuL();

        _LIT( KInvalidEntry, "*** ERROR - Invalid Command ***" );

        RedrawStatusMessage( KInvalidEntry );

        RedrawInputPrompt();

        }

    }

void CMemSpyConsoleMenu::OnCmdHeapCellListUserL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdHeapCellListUserL() - START" );

#endif

    GetProcessName();

    // Work out what to do.

    iCommandBuffer.Trim();

    if  ( iCommandBuffer.Length() > 0 )

        {

        iConsole.Write( KMemSpyConsoleNewLine );

        iConsole.Write( KMemSpyConsoleNewLine );

        //

        HBufC* cmdBuf = HBufC::NewLC( KMemSpyMaxInputBufferLength + 10 );

        TPtr pCmdBuf( cmdBuf->Des() );

        pCmdBuf.Copy( iCommandBuffer );

        pCmdBuf.Append( KMemSpyConsoleWildcardCharacter );

        TInt err;

		TProcessId procId;

		TRAP(err, procId = iSession.GetProcessIdByNameL(pCmdBuf));

		//

		if (err == KErrNone) 

			{

			RArray<CMemSpyApiThread*> threads;

			TRAP(err, iSession.GetThreadsL(procId, threads));

			if (err == KErrNone)

				{

				_LIT( KProcessingRequest, "** Dumping Heap Cell List for thread: %S" );     	

				TFullName fullThreadName;

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

					{

					CMemSpyApiThread* thread = threads[i];

					//

					fullThreadName = thread->Name();

					iConsole.Printf( KProcessingRequest, &fullThreadName );

					iConsole.Write( KMemSpyConsoleNewLine );

					//

					TRAP_IGNORE( iSession.OutputThreadCellListL(iOutputType, thread->Id()) );

					delete thread;

					}

				}

			}

        CleanupStack::PopAndDestroy( cmdBuf );

        DrawMenuL();

        }

    else

        {

        // Bad user data entry

        DrawMenuL();

        _LIT( KInvalidEntry, "*** ERROR - Invalid Command ***" );

        RedrawStatusMessage( KInvalidEntry );

        RedrawInputPrompt();

        }

    }

void CMemSpyConsoleMenu::ClearCommandBuffer()

    {

    iCommandBuffer.Zero();

    }

void CMemSpyConsoleMenu::ProcessCommandBufferL()

    {

    iCommandBuffer.Trim();

    //

#ifdef _DEBUG

    RDebug::Print( _L("[MCon] CMemSpyConsoleMenu::ProcessCommandBufferL() - cmd: [%S]"), &iCommandBuffer );

#endif

    //

    TBool validCommand = EFalse;

    if  ( iCommandBuffer.Length() == 1 )

        {

        // Reset if not recognised...

        validCommand = ETrue;

        const TChar cmd = iCommandBuffer[ 0 ]; 

        switch( cmd )

            {

        case '1':

        case 't':

        case 'T':

            OnCmdSinkTypeToggleL();

            break;

        case '2':

        case 'k':

        case 'K':

            OnCmdHeapDataKernelL();

            break;

        case '3':

        case 'o':

        case 'O':

            OnCmdKernelObjectListingL();

            break;

        case '4':

        case 'h':

        case 'H':

            OnCmdCSVListingHeapL();

            break;

        case '5':

        case 's':

        case 'S':

            OnCmdCSVListingStackL();

            break;

        case '6':

        case 'd':

        case 'D':

            OnCmdHeapDataUserL();

            break;

        case '7':

        case 'l':

        case 'L':

            OnCmdHeapCellListUserL();

            break;

        case '8':

        case 'x':

        case 'X':

            CActiveScheduler::Stop();

            return; // NB: avoid redrawing menu when exiting

        default:

            validCommand = EFalse;

            break;

            }

        }

    //

    ClearCommandBuffer();

    //

    if  ( !validCommand )

        {

        _LIT( KInvalidEntry, "*** ERROR - Invalid Command ***" );

        RedrawStatusMessage( KInvalidEntry );

        RedrawInputPrompt();

        }

    else

        {

        DrawMenuL();

        }

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::ProcessCommandBufferL() - END" );

#endif

    }

void CMemSpyConsoleMenu::RedrawInputPrompt()

    {

    iConsole.SetCursorPosAbs( iCommandPromptPos );

    iConsole.ClearToEndOfLine();

    iConsole.Printf( KMemSpyConsoleInputPrompt, &iCommandBuffer );

    }

void CMemSpyConsoleMenu::RedrawStatusMessage()

    {

    RedrawStatusMessage( KNullDesC );

    }

void CMemSpyConsoleMenu::RedrawStatusMessage( const TDesC& aMessage )

    {

    iConsole.SetCursorPosAbs( iStatusMessagePos );

    iConsole.ClearToEndOfLine();

    iConsole.Write( aMessage );

    iConsole.Write( KMemSpyConsoleNewLine );

    }

void CMemSpyConsoleMenu::GetProcessName()

    {

    iConsole.ClearScreen();

    _LIT( KPromptMessage1, "Enter the full or partial process name" );

    iConsole.Write( KPromptMessage1 );

    iConsole.Write( KMemSpyConsoleNewLine );

    _LIT( KPromptMessage2, "of the process that you are interested in." );

    iConsole.Write( KPromptMessage2 );

    iConsole.Write( KMemSpyConsoleNewLine );

    _LIT( KPromptMessage3, "Press \'enter\' when done." );

    iConsole.Write( KPromptMessage3 );

    iConsole.Write( KMemSpyConsoleNewLine );

    //

    ClearCommandBuffer();

    iConsole.Write( KMemSpyConsoleNewLine );

    iCommandPromptPos = iConsole.CursorPos();

    RedrawInputPrompt();

    //

    TBool done = EFalse;

    while( !done )

        {

        // Get a key

        const TKeyCode key = iConsole.Getch();

        // Process it