/*

* Copyright (c) 2007 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:  Class definition of CDiagPluginExecPlanImpl

*

*/

// CLASS DECLARATION

#include "diagpluginexecplanimpl.h"

// SYSTEM INCLUDE FILES

#include <e32def.h>

#include <cstack.h>                     // CStack

#include <DiagPlugin.h>                 // MDiagPlugin

#include <DiagSuitePlugin.h>            // MDiagSuitePlugin

#include <DiagTestPlugin.h>             // MDiagTestPlugin

#include <DiagPluginPool.h>             // CDiagPluginPool

#include <DiagResultsDatabase.h>        // RDiagResultsDatabaseRecord

#include <DiagResultsDbItemBuilder.h>   // CDiagResultsDbItemBuilder

#include <DiagResultDetail.h>           // MDiagResultDetail

#include <DiagFrameworkDebug.h>         // For debug log

#include <DiagResultsDbRecordEngineParam.h> // CDiagResultsDbRecordEngineParam

// USER INCLUDE FILES

#include "diagframework.pan"            // panic codes

#include "diagexecplanentryimpl.h"      // CDiagExecPlanEntryImpl

#include "diagexecplanentryimpltest.h"  // CDiagExecPlanEntryImplTest

#include "diagexecplanentryimplsuite.h" // CDiagExecPlanEntryImplSuite

#include "diagcleanupresetanddestroy.h" // CleanupRPointerArrayPushL

#include "diagengineconfig.h"           // TDiagEngineConfig

// DATA

// MACROS

// Uncomment the line below to enable more plan creation log.

// #define _DEBUG_EXEC_PLAN

// LOCAL DATA TYPES

/**

* Used for keeping track of suite level stack.

* It is used in InsertSuiteTransitionsL() function. ( STEP_5 )

*/

struct TTransitionStackEntry

    {

    /**

    * iLeavelUid - Uid of the current level. 

    */

    TUid  iLevelUid;

    /**

    * iPrepareIndex - Index in the plan where ETypeSuitePrepare entry is. 

    *   This information is used to update the suite iAsDependent field.

    */

    TInt    iPrepareIndex;         

    };    

// ======== LOCAL FUNCTIONS ========

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

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

// CDiagPluginExecPlanImpl::NewL

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

//

CDiagPluginExecPlanImpl* CDiagPluginExecPlanImpl::NewL( 

        MDiagEngineCommon& aEngine,

        const TDiagEngineConfig& aEngineConfig,

        MDiagExecPlanEntryImplObserver& aEntryObserver )

    {

    CDiagPluginExecPlanImpl* self = new ( ELeave ) CDiagPluginExecPlanImpl( 

        aEngine,

        aEngineConfig,

        aEntryObserver );

    return self;

    }

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

// CDiagPluginExecPlanImpl::CDiagPluginExecPlanImpl

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

//

CDiagPluginExecPlanImpl::CDiagPluginExecPlanImpl( 

        MDiagEngineCommon& aEngine,

        const TDiagEngineConfig& aEngineConfig,

        MDiagExecPlanEntryImplObserver& aEntryObserver )

    :   CActive( EPriorityLow ),

        iEngine( aEngine ),

        iEngineConfig( aEngineConfig ),

        iPlanEntryObserver( aEntryObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CDiagPluginExecPlanImpl::~CDiagPluginExecPlanImpl

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

//

CDiagPluginExecPlanImpl::~CDiagPluginExecPlanImpl()

    {

    Cancel();

    iPlan.ResetAndDestroy();

    iPlan.Close();

    iExecutedEntries.ResetAndDestroy();

    iExecutedEntries.Close();

    }

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

// CDiagPluginExecPlanImpl::InitaliazeL

//      Creating a fresh session.

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

//

void CDiagPluginExecPlanImpl::InitializeL( TRequestStatus& aStatus, 

                                           const RPointerArray< MDiagPlugin >& aBatch )

    {

    LOGSTRING( "CDiagPluginExecPlanImpl::InitializeL: new session")

    __ASSERT_ALWAYS( iState == EStateIdle, Panic( EDiagFrameworkInternal ) );

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    iExecutedEntries.ResetAndDestroy();

    iPlan.ResetAndDestroy();

    iResumeIndex = 0;

    // pre-step execution step. copy the argument to a local plan

    TInt i;

    for ( i = 0; i < aBatch.Count();  i++ )

        {

        __ASSERT_ALWAYS( aBatch[i] != NULL, Panic( EDiagFrameworkBadArgument ) );

        CDiagExecPlanEntryImpl* newEntry = CreateDefaultPlanEntryLC(

            *(aBatch[i]),

            EFalse );   // aAsDependency

        iPlan.AppendL( newEntry );  // ownership transferred.

        CleanupStack::Pop( newEntry ); 

        newEntry = NULL;

        }

    LOGSTRING( "CDiagPluginExecPlanImpl::InitializeL: Initial Batch" )

    LogPlanL();

    ChangeState( EStateExpandDependencyAndSuites );

    }

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

// CDiagPluginExecPlanImpl::InitializeL

//      Continuing from incomplete session.

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

//

void CDiagPluginExecPlanImpl::InitializeL( TRequestStatus& aStatus )

    {

    LOGSTRING( "CDiagPluginExecPlanImpl::InitaliazeL: continue" )

    // validate input.

    __ASSERT_ALWAYS( iState == EStateIdle, Panic( EDiagFrameworkInternal ) );

    // if we are resuming incomplete session, it must incomplete.

    TBool isRecordCompleted = EFalse;

    User::LeaveIfError( iEngine.DbRecord().IsTestCompleted( isRecordCompleted ) );

    __ASSERT_ALWAYS( !isRecordCompleted, Panic( EDiagFrameworkBadArgument ) );

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    iResumeIndex = 0;

    iExecutedEntries.ResetAndDestroy();

    iPlan.ResetAndDestroy();

    // Retrieve records from database and use it as base for creating 

    // a new plan.

    RPointerArray< CDiagResultsDatabaseItem > previousResults;

    DiagFwInternal::CleanupRPointerArrayPushL< CDiagResultsDatabaseItem >( &previousResults );

    User::LeaveIfError( 

        iEngine.DbRecord().GetTestResults( previousResults ) );

    TInt resultCount = previousResults.Count();

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

        {

        // Get the test plug-in.

        // Note that FindPlugin does not transfer ownership and hence testPlugin

        // and does not need to be deallocated.

        MDiagPlugin& testPlugin = 

            iEngine.PluginPool().FindPluginL( previousResults[i]->TestUid() );

        // This should have been a test plug-in

        __ASSERT_DEBUG( testPlugin.Type() == MDiagPlugin::ETypeTestPlugin,

            Panic( EDiagFrameworkInternal ) );

        CDiagExecPlanEntryImplTest* testEntry = 

            CDiagExecPlanEntryImplTest::NewLC( 

                iEngine,

                iEngineConfig,

                iPlanEntryObserver,

                static_cast< MDiagTestPlugin& >( testPlugin ),

                previousResults[i]->WasDependency(),

                previousResults[i]->TestResult() );

        if ( testEntry->Result() == CDiagResultsDatabaseItem::EQueuedToRun )

            {

            // it was queued to be executed.

            iPlan.AppendL( testEntry ); // ownership transferred.

            }

        else

            {

            // it was already executed. 

            iExecutedEntries.AppendL( testEntry ); // ownership transferred.

            }

        CleanupStack::Pop( testEntry );

        testEntry = NULL;

        }

    CleanupStack::PopAndDestroy( &previousResults );

    iResumeIndex = iExecutedEntries.Count();

    if ( iResumeIndex != 0 )

        {

        LOGSTRING( "CDiagPluginExecPlanImpl::InitializeL: Queued Items" )

        LogPlanL();

        ChangeState( EStateExpandDependencyAndSuites );

        }

    else

        {

        LOGSTRING( "CDiagPluginExecPlanImpl::InitializeL: "

            L"Items in DB may be invalid. Fully recreate plan" )

        // If iResumeIndex is 0, it means that all items in the db are 

        // marked as EQueuedToRun. Because of the async nature of db,

        // it could also indicate that not previous plan was not fully

        // written to the database. In this case, read the engine parameter

        // and try to recreate the plan from scratch.

        //

        // If it was already fully written but hadn't had a chance to really

        // execute anything, this will not cause any ill effects since

        // plan created should be identical and simply reset 

        // all results in db to EQueuedToRun.

        iExecutedEntries.ResetAndDestroy();

        iPlan.ResetAndDestroy();

        RPointerArray< MDiagPlugin > batch;

        CleanupClosePushL( batch );    // items are not owned, so no need for "Destroy"

        CDiagResultsDbRecordEngineParam* engineParam = NULL;

        User::LeaveIfError( 

            iEngine.DbRecord().GetEngineParam( engineParam ) );

        CleanupStack::PushL( engineParam );

        const RArray< TUid >& batchUids = engineParam->ExecutionsUidArray();

        // Read original Uids from previous engine param.

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

            {

            MDiagPlugin* testPlugin = NULL;

            User::LeaveIfError( 

                iEngine.PluginPool().FindPlugin( batchUids[i], testPlugin ) );

            __ASSERT_DEBUG( testPlugin != NULL, Panic( EDiagFrameworkInternal ) );

            if ( testPlugin )  //lint !e774 This will be evaluated on non-debug build.

                {

                batch.AppendL( testPlugin );

                }

            }

        CleanupStack::PopAndDestroy( engineParam );

        engineParam = NULL;

        // Call the normal InitializeL() method as if it is a new session.

        InitializeL( aStatus, batch );

        CleanupStack::PopAndDestroy( &batch );  // calls Close()

        }

    }

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

// CDiagPluginExecPlanImpl::operator[]

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

//

CDiagExecPlanEntryImpl& CDiagPluginExecPlanImpl::operator[]( TInt aIndex )

    {

    return *iPlan[aIndex];

    }

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

// CDiagPluginExecPlanImpl::CurrentExecutionItem

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

//

CDiagExecPlanEntryImpl& CDiagPluginExecPlanImpl::CurrentExecutionItem() 

    {

    return *iPlan[iExecutionCursor];

    }

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

// CDiagPluginExecPlanImpl::ResetExecutionCursor

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

//

void CDiagPluginExecPlanImpl::ResetExecutionCursor()

    {

    iExecutionCursor = 0;

    }

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

// CDiagPluginExecPlanImpl::MoveCursorToNext

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

//

TBool CDiagPluginExecPlanImpl::MoveCursorToNext()

    {

    TBool value = EFalse;

    if ( iExecutionCursor < iPlan.Count() - 1 )

        {

        iExecutionCursor++;

        value = ETrue;

        }

    else

        {

        // cannot move beyond the last item.

        }

    return value;

    }

// ======== From CActive =========

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

// From CActive

// CDiagPluginExecPlanImpl::RunL

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

//

void CDiagPluginExecPlanImpl::RunL()

    {

    /*----------------------------------------------------------------------

       Create execution plan:

       Overview:

            STEP_1. Expand Dependency 

            STEP_2. Expand Suites.

            STEP_3. Repeat STEP_1 & STEP_2 until no changes are made to the plan

            STEP_4. Check and remove empty suites

            STEP_5. Add Prepare/Finalize suite execution.

            STEP_6. Store execution plan to results db. 

            STEP_7. Append items that were executed in the previous test

                    to the beginning of the test.

       Details:

        STEP_1. Expand Dependency

            In this step, each item is checked for dependency and 

            dependent items will be inserted into plan.

            Note that if dependent item also depends on something else, those

            will be added immediately.

            All items inserted during this phase is inserted as dependent.

        STEP_2. Expand suites

            Suites are expandeded to individual tests or suites. Suite

            item will be expanded between parent suite's Prepare and 

            Finalize items. 

            iAsDependent value will be inherited from the parent suite

            that it expanded from. E.g. if suite was dependent, then so will

            all the items that included from that suite.

            Note that it does not remove the original suite entry in the plan. 

            This is to make sure that dependencies inserted will be grouped

            within the same group as the plug-ins that depended on it.

            If they are removed, and re-inserted later in STEP_5, it will

            cause the dependent items to be outside of the original grouping.

                e.g.  S1 = {P1}

                      S2 = {P2, P3}

                      and P2 depends on P1

                When dependency and suites are expanded with original

                suite removed, after STEP_3, the plan will look like this:

                    (* indicates iAsDependent == ETrue)

                      0     1    2

                      *P1   P2   P3

                When it tries to add suite transition back in to the plan,

                it will look like this:

                    (* indicates iAsDependent == ETrue)

                    (< indicates suite prepare execution.)

                    (> indicates suite finalize execution.)

                      0    1    2    3    4   5   6

                      <S1  *P1  S1>  <S2  P2  P3  S2>

                which is somewhat incorrect since *P1 is added due to 

                dependency. 

                Instead, if original suite grouping is kept, after STEP_3

                    0    1    2    3    4

                    <S2  *P1  P2   P3   S2>

                After STEP_5

                    0    1    2    3    4   5   6

                    <S2  <S1  *P1  S1>  P2  P3  S2>

                which is more correct.

            Note that this will be done in breadth first style. If there is a

            nested suites, it will not be expanded until next cycle. 

            This is to allow dependencies of the suite to be expanded before

            being removed.

        STEP_3. Repeat STEP_1 & STEP_2 until no changes are made.

            This step ensures that suites are expanded, and all dependent

            items are added to the plan.

        STEP_4. Remove Empty suites

            Because dependent items can be moved, it is possible that plan ends

            up with empty suites. This section will check for 

            suite prepare/finalize that has nothing inside, and remove them.

        STEP_5. Add Prepare/Finalize steps for suites.

            As a final step, it will navigate all the entries in the plan, and

            insert proper prepare/finalize steps. This is based on stack,

            where every suite prepare is pushed into a stack, and poped when

            suite finalize is called. e.g. consider following plug-ins:

                S1 = { P1, P2 }

                S2 = { P3, P4 }

                And P3 depends on P2.

            And resulting plan after STEP_4 looked like this:

                0    1     2    3    4

                <S2  *P2   P3   P4   S2>

            After STEP_5, it should look like this:

                0    1    2    3    4    5    6

                <S2  <S1  *P2  S1>  P3   P4   S2>

        STEP_6. Store execution plan to results db. 

            This allows continuation of the incomplete results.

            Only test plug-ins are written to the database. 

        STEP_7. Append items that were executed in the previous test

            to the beginning of the test.

        Other Notes:

        NOTE_1) This logic currently does not check for circular dependencies.

           If circular dependency exists, the program will go into an

           infinite loop in ExpandDependenciesL().

        NOTE_2) Inserting duplicate items.

            Due to dependencies, duplicate entries may exist in the plan.

            When items are inserted during STEP_1 - STEP_2, it will be checked

            for duplicates.

            Duplicate removal policy is as follows:

            RULE_A) If an item with "iAsDependent == ETrue" is being inserted,

                AND if an item already exist in the plan before current index,

                then it will not be inserted. 

            RULE_B) Any items inserted with "iAsDependent == EFalse" will 

               always be inserted at the requested index.

               This is because they are considered to be user input, and

               plan will not try to re-order the execution order that 

               client or user has specified.

            RULE_C) The first instance of an item has higher priority than later

               instances. Later instace of duplicate will be removed, unless

               it violates RULE_B. (e.g. item has "iAsDependent == EFalse".)

            This has a side effect: item may execute twice in certain cases.

            E.g. original plan has two plug-ins:  P1, P2, P3

            P1 depends on P2, and P3 also depends ond P2

            Original Input:   0   1   2

                              P1  P2  P3

            After STEP_3, it should look like this. 

                    (* indicates iAsDependent == ETrue)

                              0    1    2   3    4

                              *P2  P1   P2  *P2  P3

            During STEP_4, duplicates are removed, and it should look like this:

                    (* indicates iAsDependent == ETrue)

                              0    1    2   4

                              *P2  P1   P2  P3

            Note that there are two P2s in the plan; 

            at 0 with iAsDependent == ETrue and at 2 with iAsDependent == EFalse

            There may be some discussions on whether this is how it should be.

            However, at this point, it seems that it is more important that

            execution appears to the user in the order specified. 

            To make sure that user sees that P2 is executed only once, plug-in

            developer may need to make sure that if a plug-in provides services,

            it should also handle cases where it is executed twice.

            In reality, such cases can be avoided by grouping the plug-ins 

            in the correct order, hence it should not be an issue.

    ----------------------------------------------------------------------*/

    // First, error handling.

    LOGSTRING3( "CDiagPluginExecPlanImpl::RunL: State = %d, Err = %d",