/*

* 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 <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>

// User includes

#include "MemSpyCommands.h"

CMemSpyCommandLine::CMemSpyCommandLine()

    }

CMemSpyCommandLine::~CMemSpyCommandLine()

    {

        {

        }

    iFsSession.Close();

    }

void CMemSpyCommandLine::ConstructL()

    {

    }

    {

    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 ) );

    if  ( count >= 1 )

        {

        // 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;

    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 ) );

    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;

    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

    CleanupStack::Pop( lines );

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

    return lines;

    }

void CMemSpyCommandLine::ParseSWMTParametersL( const CDesCArray& aParameters, TInt& aCategories, TDes& aFilter )

    {

    TInt result(0);

    // Check if the first parameter is a number.

    // In that case other parameters are ignored.

    TLex lex( aParameters[ 0 ] );

    if ( lex.Val( result ) != KErrNone )

        // Parameters were given in text form:

        const TInt count( aParameters.Count() );

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

            {