/*

* Copyright (c) 2008 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:  CAlfPerfAppTestCaseSelectionView implementation.

*

*/

#include <aknutils.h>

#include <aknviewappui.h>

#include <alfperfapp.rsg>

#include <stringloader.h>

#include <AknBidiTextUtils.h>

#include <aknutils.h>

#include <aknnotewrappers.h>

#include <eiksbfrm.h>

#include <akndef.h>

#include <bautils.h> 

#include "alfperfapptestcaseselectionview.h"

#include "alfperfapp.hrh"

#include "alfperfappconstants.h"

#include "alfperfappmodel.h"

// Execution ongoing

_LIT( KAlfPerfAppExecuting, "Executing..\n" );

// Print output path

_LIT( KAlfPerfAppPrintOutputFormat, "Result files are in %S\n" );

// Error message display

_LIT( KAlfPerfAppNoErrors, "No errors.\n\n" );

_LIT( KAlfPerfAppErrorHeader, "Errors:\n" );

_LIT( KAlfPerfappErrorItem, "  %S\n" );

_LIT( KAlfPerfAppErrorFooter, "\n" );

// Results display

_LIT( KAlfPerfAppInfoNote, "Program records results directly to two files, results are appended to the end of each file.\n\n");

_LIT( KAlfPerfAppClearFilesQueryLine1, "Earlier results present.");

_LIT( KAlfPerfAppClearFilesQueryLine2, "Clear the result files?");

_LIT( KAlfPerfAppResultsHeader, 

        "*** Field Guide ***\n- Time spend\n- Mem.usage of app,server and system\n- Frame count and fps\n");

//_LIT( KAlfPerfAppResultsCaseStart, "%.2f s: Case: %x\n" );

_LIT( KAlfPerfAppResultsCaseStart, "Started at: %.2f s\n");

_LIT( KAlfPerfAppResultsCaseTitle, "\n=== %S / %S (0x%x) ===\n");

_LIT( KAlfPerfAppResultsNone, "No results.\n\n" );

_LIT( KAlfPerfAppSpecificResultFooter,"\n");

_LIT( KAlfPerfAppResultsPhaseTitle0,"\n*** Startup ***\n" );

_LIT( KAlfPerfAppResultsPhaseTitle1,"\n*** Run ***\n" );

_LIT( KAlfPerfAppResultsPhaseTitle2,"\n*** Teardown ***\n" );

_LIT( KAlfPerfAppResultsCaseTotalTitle,"\n*** Case total ***\n" );

_LIT( KAlfPerfAppResultsCaseItem,

        "Time: %.2f s\nMem.usage: %d/%d/%d kb\nFrames: %d (%3.1f fps)\n" );

// Buffer full

const TInt KAlfPerfAppDisplayResultMaxChars = 35000; //increase is needed for Sequence test cases

_LIT( KAlfPerfAppDisplayBufferFull,"\n*** Display buffer full ***\n");

/**

 * CAlfPerfAppTestCaseSelectionView::CContainer container class.

 */

class CAlfPerfAppTestCaseSelectionView::CContainer : public CCoeControl, MCoeControlObserver, MEikScrollBarObserver

    {

    public:

        CContainer(CAlfPerfAppModel* aModel);

        void ConstructL();

        ~CContainer();

    public: // New functions

        TBool PrintText(const TDesC& aDes);

        void ClearOutputWindowL();

        void UpdateVisualContentL(TBool aScrollToBottom);

    public: // From base classes

        virtual TKeyResponse OfferKeyEventL( 

                const TKeyEvent& aKeyEvent, TEventCode aType );

        virtual void HandleResourceChange( TInt aType );

        virtual void Draw(const TRect& aRect) const;

        virtual void HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType);

        virtual void HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType); // From MEikScrollBarObserver

    private:

        CEikScrollBarFrame*     iScrollBarFrame;

        HBufC*                  iText;

        CFont*                    iFont;

        HBufC*                  iWrapperString;

        CArrayFix<TPtrC>*       iWrappedArray;

        TInt                    iCurrentLine;

        TInt                    iLineCount;

        TInt                    iNumberOfLinesFitsScreen;   

        TInt                    iLeftDrawingPosition;

        TReal                   iX_factor;

        TReal                   iY_factor;

        TBool                   iNotPrintedResultDisplayBufferExceeded;

        CAlfPerfAppModel*       iModel;

    };

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

//

CAlfPerfAppTestCaseSelectionView* CAlfPerfAppTestCaseSelectionView::NewLC(

        CAlfPerfAppModel& aModel )

    {

    CAlfPerfAppTestCaseSelectionView* self = 

    new (ELeave) CAlfPerfAppTestCaseSelectionView( aModel );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

//

CAlfPerfAppTestCaseSelectionView::~CAlfPerfAppTestCaseSelectionView()

    {

    }

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

//

CAlfPerfAppTestCaseSelectionView::CAlfPerfAppTestCaseSelectionView(

        CAlfPerfAppModel& aModel )

: iModel( aModel )

       {

       }

        // -----------------------------------------------------------------------------

        // -----------------------------------------------------------------------------

        //

        void CAlfPerfAppTestCaseSelectionView::ConstructL()

            {

            BaseConstructL( R_ALFPERFAPP_TEST_CASE_SELECTION_VIEW );

            }

        // -----------------------------------------------------------------------------

        // -----------------------------------------------------------------------------

        //

        void CAlfPerfAppTestCaseSelectionView::CmdRunAllL()

            {

            // Run all test cases (that are not excluded from 'run all').

            iModel.ResetErrorArray();

            if (iContainer)

                {

                iContainer->ClearOutputWindowL();

                iContainer->PrintText( KAlfPerfAppExecuting );

                }

            iModel.ResetExecuteArray();

            const TInt suiteCount = iModel.SuiteCount();

            for ( TInt ii = 0; ii < suiteCount; ii++ )

                {

                // If suite is not excluded from run all, 

                // add all test cases to execute array.

                if ( !( iModel.SuiteFlags( ii ) & 

                        EAlfPerfAppTestSuiteFlagExcludeFromRunAll ) )

                    {

                    // Add all test cases to execute array.

                    const TInt testCount = iModel.TestCaseCount( ii );

                    for ( TInt jj = 0; jj < testCount; jj++ )

                        {

                        TPtrC testName;

                        TInt testCaseId;

                        TInt testCaseFlags;

                        TInt testCaseSequenceLength;

                        iModel.GetTestCase(

                                ii,

                                jj,

                                testName,

                                testCaseId,

                                testCaseFlags,

                                testCaseSequenceLength);

                        // Add the test case multiple times to fill the sequence (at least once though)

                        iModel.AddToExecuteArrayL( testCaseId );

                        for(TInt index = 1; index < testCaseSequenceLength;index++)

                            {

                            iModel.AddToExecuteArrayL( testCaseId );

                            }

                        }

                    }

                }

            AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId );

            }

        void CAlfPerfAppTestCaseSelectionView::CmdRunAllContinuouslyL()

            {

            // Run all test cases (that are not excluded from 'run all').

            iModel.ResetErrorArray();

            if (iContainer)

                {

                iContainer->ClearOutputWindowL();

                iContainer->PrintText( KAlfPerfAppExecuting );

                }

            iModel.ResetExecuteArray();

            const TInt suiteCount = iModel.SuiteCount();

            for ( TInt ii = 0; ii < suiteCount; ii++ )

                {

                // If suite is not excluded from run all, 

                // add all test cases to execute array.

                if ( !( iModel.SuiteFlags( ii ) & 

                        EAlfPerfAppTestSuiteFlagExcludeFromRunAll ) )

                    {

                    // Add all test cases to execute array.

                    const TInt testCount = iModel.TestCaseCount( ii );

                    for ( TInt jj = 0; jj < testCount; jj++ )

                        {

                        TPtrC testName;

                        TInt testCaseId;

                        TInt testCaseFlags;

                        TInt testCaseSequenceLength;

                        iModel.GetTestCase(

                                ii,

                                jj,

                                testName,

                                testCaseId,

                                testCaseFlags,

                                testCaseSequenceLength);

                        // Add the test case multiple times to fill the sequence (at least once though)

                        iModel.AddToExecuteArrayL( testCaseId );

                        for(TInt index = 1; index < testCaseSequenceLength;index++)

                            {

                            iModel.AddToExecuteArrayL( testCaseId );

                            }

                        }

                    }

                }

            // Finally tell ExecutionView to use Continuous Run

            const TUid KCustomMessageUid = {2};

            TBuf8<KAlfPerfAppMaxCharsInLine> customMessage;

            customMessage.Copy(_L8("UseContinuousRun"));

            AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId,KCustomMessageUid,customMessage);

            }

        // -----------------------------------------------------------------------------

        // -----------------------------------------------------------------------------

        //

        void CAlfPerfAppTestCaseSelectionView::CmdRunAllFromSuiteL( 

                TInt aSuiteIndex )

            {

            // Run all test cases related to specific suite.

            const TInt testCaseCount = iModel.TestCaseCount( aSuiteIndex );

            iModel.ResetErrorArray();

            if (iContainer)

                {

                iContainer->ClearOutputWindowL();

                iContainer->PrintText( KAlfPerfAppExecuting );

                }

            iModel.ResetExecuteArray();

            for ( TInt ii = 0; ii < testCaseCount; ii++ )

                {

                TPtrC testCaseName;

                TInt testCaseId;

                TInt testCaseFlags;

                TInt testCaseSequenceLength;

                iModel.GetTestCase(

                        aSuiteIndex,

                        ii,

                        testCaseName,

                        testCaseId,

                        testCaseFlags,

                        testCaseSequenceLength);

                // Add the test case multiple times to fill the sequence (at least once though)

                iModel.AddToExecuteArrayL( testCaseId );

                for(TInt index = 1; index < testCaseSequenceLength;index++)

                    {

                    iModel.AddToExecuteArrayL( testCaseId );

                    }

                AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId );

                }

            }

        // -----------------------------------------------------------------------------

        // -----------------------------------------------------------------------------

        //

        void CAlfPerfAppTestCaseSelectionView::CmdRunTestCaseL( 

                TInt aSuiteIndex, TInt aTestCaseIndex )

            {

            TPtrC testCaseName;

            TInt testCaseId;

            TInt testCaseFlags;

            TInt testCaseSequenceLength;

            iModel.GetTestCase(

                    aSuiteIndex,

                    aTestCaseIndex,

                    testCaseName,

                    testCaseId,

                    testCaseFlags,

                    testCaseSequenceLength);

            iModel.ResetErrorArray();

            if (iContainer)

                {

                iContainer->ClearOutputWindowL();

                iContainer->PrintText( KAlfPerfAppExecuting );

                }

            iModel.ResetExecuteArray();

            // Add the test case multiple times to fill the sequence (at least once though)

            iModel.AddToExecuteArrayL( testCaseId );

            for(TInt index = 1; index < testCaseSequenceLength;index++)

                {

                iModel.AddToExecuteArrayL( testCaseId );

                }

            AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId );

            }

        // -----------------------------------------------------------------------------

        // -----------------------------------------------------------------------------

        //

        TUid CAlfPerfAppTestCaseSelectionView::Id() const

        {

        return KAlfPerfAppTestCaseSelectionViewId;

        }

        // -----------------------------------------------------------------------------

        // Handles view activation

        // -----------------------------------------------------------------------------

        //

        void CAlfPerfAppTestCaseSelectionView::DoActivateL(

                const TVwsViewId& /*aPrevViewId*/,

                TUid /*aCustomMessageId*/,

                const TDesC8& /*aCustomMessage*/ )

            {

            ResetContainerL();

            DisplayResultsL();

            // Pop up the "Clear result files?"-dialog if either of the files existed.

            static TBool firstTime = ETrue;

            if(firstTime)

                {

                if(iModel.TargetFilesExisted())

                    {

                    if(CEikonEnv::Static()->QueryWinL(KAlfPerfAppClearFilesQueryLine1,KAlfPerfAppClearFilesQueryLine2))

                        {

                        // Clear the files

                        iModel.OpenFilesL(true);

                        }

                    firstTime = EFalse;

                    }

                }

            }

        // -----------------------------------------------------------------------------

        // Handles view deactivation

        // -----------------------------------------------------------------------------

        //

        void CAlfPerfAppTestCaseSelectionView::DoDeactivate()

            {

            if ( iContainer )

                {

                AppUi()->RemoveFromStack( iContainer );

                delete iContainer;

                iContainer = NULL;

                }

            }

        // -----------------------------------------------------------------------------

        // Display test results on screen. The text is wrapped.

        // -----------------------------------------------------------------------------

        //

        void CAlfPerfAppTestCaseSelectionView::DisplayResultsL()

             {

            if (iContainer)

                {

                TBuf<KAlfPerfAppMaxCharsInLine> line;

                iContainer->ClearOutputWindowL();

                const TInt errorCount = iModel.ErrorArrayCount();

                if ( !errorCount )

                    {

                    iContainer->PrintText( KAlfPerfAppNoErrors );

                    }

                else

                    {

                    iContainer->PrintText( KAlfPerfAppErrorHeader );

                    for ( TInt ii = 0; ii < errorCount; ii++ )

                        {

                        TPtrC message;

                        iModel.GetFromErrorArray( ii, message );

                        if ( message.Length() )

                            {

                            line.Zero();

                            TPtrC item = message.Left( 64 );

                            line.Format( KAlfPerfappErrorItem, &item );

                            iContainer->PrintText( line );

                            }

                        }

                    iContainer->PrintText( KAlfPerfAppErrorFooter );

                    }

                if (iModel.ResultsNotAddedToFile())

                    {           

                    iContainer->PrintText( KAlfPerfAppResultsNone );

                    iContainer->PrintText( KAlfPerfAppInfoNote );

                    }    

                else

                    {  

                    line.Zero();

                    line.Format( KAlfPerfAppResultsHeader ); 

                    iContainer->PrintText(line);

                    // Prepare to read lines

                    TFileText LineFromFile;

                    LineFromFile.Set(*iModel.ResultFile());

                    LineFromFile.Seek(ESeekStart);

                    // Read the first line and forget it (header info only)

                    line.Copy(getLineFromTargetFile());

                    TInt currentCase = 0;

                    TBool startTimeNotRecorded = ETrue;

                    TUint32 timeStampAtStart = 0;

                    TInt framesSinceCase = 0;

                    CAlfPerfAppModel::TTestCaseResultItem itemAtCase;

                    CAlfPerfAppModel::TTestCaseResultItem itemAtPhase;

                    TBuf8<KAlfPerfAppMaxCharsInSpecificResultText> specificResultStorage;

                    for(TInt i=0; ; i++) // i = line number in result file

                        {

                        line.Zero();

                        // Read a line from file and convert it to an TTestCaseResultItem

                        line.Copy(getLineFromTargetFile());

                        if(line.Length() == 0)

                            {

                            // If the line is empty, end this loop

                            break;

                            }

                        CAlfPerfAppModel::TTestCaseResultItem item;

                        item = ResultItemFromLine(line);

                        line.Zero();

                        if(startTimeNotRecorded)

                            {

                            timeStampAtStart = item.iTimeStamp;

                            startTimeNotRecorded = EFalse;

                            }

                        TUint32 timeFromStart = 

                        DeltaFromCurrentToPrevious( 

                                item.iTimeStamp, timeStampAtStart );

                        TBool changedCase = EFalse;

                        if ( !i || currentCase != item.iCaseId )

                            {

                            currentCase = item.iCaseId;

                            itemAtCase = item;

                            framesSinceCase = 0;

                            changedCase = ETrue;

                            //specificResultStorage.Zero(); 

                            }

                        if(changedCase || itemAtPhase.iPhase != item.iPhase)

                            {

                            itemAtPhase = item;

                            }

                        if ( changedCase )

                            {

                            // Name

                            TBuf<100> suiteName;

                            suiteName.Copy(item.iSuiteName);

                            TBuf<100> caseName;

                            caseName.Copy(item.iCaseName);

                            line.Format( 

                                    KAlfPerfAppResultsCaseTitle,                           

                                    &suiteName,

                                    &caseName,

                                    item.iCaseId);

                            if(!iContainer->PrintText(line))break;

                            line.Zero();

                            // Start time

                            line.AppendFormat( KAlfPerfAppResultsCaseStart, 

                                    ((TReal32)timeFromStart/1000));

                            if(!iContainer->PrintText(line))break;

                            line.Zero();

                            }

                        if(item.specificResult8.Length() != 0)

                            {

                            specificResultStorage.Zero();

                            specificResultStorage.Append(item.specificResult8);

                            }

                        if(i&0x1) // Skip even lines

                            {

                            // Print phase data

                            if (item.iPhase == 0)

                                {

                                line.AppendFormat(KAlfPerfAppResultsPhaseTitle0);

                                }

                            else if (item.iPhase == 1)

                                {