/*

* 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: This module contains implementation of CConsoleMain 

* and CModule class member functions.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32cons.h>

#include <e32svr.h>

#include <f32file.h>

#include <hal.h>

#include <hal_data.h>

#include <stifinternal/UIStoreIf.h>

#include "ConsoleUI.h"

#include "ConsoleMenus.h"

#include "StifTestInterface.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

_LIT(KNameTxt,"STIF");

_LIT( KConsoleMain, "CConsoleMain" );

// Commandline params

_LIT( KTestModule,      "-testmodule" );

_LIT( KTestModuleIni,   "-testmoduleini" );

_LIT( KTestCaseFile,    "-testcasefile" );

_LIT( KTestSet,         "-testset" );

_LIT( KTestRun,         "-run" );

_LIT( KTestRunAll,      "all" );

_LIT( KTestRunSeq,      "sequential" );

_LIT( KTestRunPar,      "parallel" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

LOCAL_C void MainL();

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

// None

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

/*

-------------------------------------------------------------------------------

    Class: CConsoleMain

    Method: NewL

    Description: Construct the console main class

    Parameters: None

    Return Values: CConsoleMain*                    New object

    Errors/Exceptions: Leaves if memory allocation fails or

                       ConstructL leaves.

    Status: Draft

-------------------------------------------------------------------------------

*/

CConsoleMain* CConsoleMain::NewL( )

    {

    CConsoleMain* self = new ( ELeave ) CConsoleMain();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

/*

-------------------------------------------------------------------------------

    Class: CConsoleMain

    Method: ConstructL

    Description: Second level constructor.

    Construct the console

    Construct module and case containers

    Retrieve command line parameters

    Connect to test engine

    Parameters: None

    Return Values: None

    Errors/Exceptions: Leaves if memory allocation fails or fileserver or

                       test engine can't be connected.

    Status: Draft

-------------------------------------------------------------------------------

*/

void CConsoleMain::ConstructL( )

    {

    _LIT( KEnableMaximised,  "+Maximised" );

    //_LIT( KDisableMaximised, "-Maximised" );

    _LIT( KEnableInform,     "+Inform" );

    //_LIT( KDisableInform,    "-Inform" );

    _LIT( KEnableRaw,        "+Raw" );

    //_LIT( KDisableRaw,       "-Raw" );

    _LIT( KEnablePointer,    "+Pointer" );

    //_LIT( KDisablePointer,   "-Pointer" );

    //_LIT( KDescription,   "-Pointer" );

    CUIStoreIf::ConstructL();

    rConsoleCreated = false;

    // Construct the console

    //iConsole = Console::NewL( KNameTxt,

    //                         TSize( KConsFullScreen, KConsFullScreen ) );

    TInt ret = iConsole.Create(); 

    if(ret != KErrNone)

    	{

    	RDebug::Print(_L("Could not create console, err = (%d)"), ret);

    	User::Leave(ret);

    	}

    rConsoleCreated = true;

    ret = iConsole.Init(KNameTxt, TSize( KConsFullScreen, KConsFullScreen ));

    if(ret != KErrNone)

    	{

    	RDebug::Print(_L("Could not initialize console, err = (%d)"), ret);

    	User::Leave(ret);

    	}

    ret = iConsole.Control( KEnableMaximised );

    if(ret != KErrNone)

    	{

    	RDebug::Print(_L("Could not initialize console controls(+Maximised), err = (%d)"), ret);

    	User::Leave(ret);

    	}

    ret = iConsole.Control( KEnableInform );

    if(ret != KErrNone)

        	{

        	RDebug::Print(_L("Could not initialize console controls(+Inform), err = (%d)"), ret);

        	User::Leave(ret);

        	}

    ret = iConsole.Control( KEnablePointer );

    if(ret != KErrNone)

        	{

        	RDebug::Print(_L("Could not initialize console controls(+Pointer), err = (%d)"), ret);

        	User::Leave(ret);

        	}

    ret = iConsole.Control( KEnableRaw );

    if(ret != KErrNone)

        	{

        	RDebug::Print(_L("Could not initialize console controls(+Raw), err = (%d)"), ret);

        	User::Leave(ret);

        	}

    RDebug::Print(_L("Creating module list object"));

    TRAPD(err, iModuleList = CTestModuleList::NewL(NULL));

    if(err != KErrNone)

        {

        RDebug::Print(_L("Could not create module list (%d)"), err);

        UiError(_L("Could not create module list (err)"));

        User::Leave(err);

        }

    if(!iModuleList)

        {

        RDebug::Print(_L("Could not create module list (NULL)"));

        UiError(_L("Could not create module list (NULL)"));

        User::Leave(KErrGeneral);

        }

    // Get command line parameters

    TFileName iniFile; // TestFramework initialization file

    ProcessCommandlineL( iniFile );

    if(iTestModule)

        {

        // Add to module list info about module taken from command line

        RDebug::Print(_L("Adding command line module to list"));

        TName moduleName;

        moduleName.Copy(iTestModule->Des());

        moduleName.LowerCase();

        err = iModuleList->AddTestModule(moduleName);

        if(err != KErrNone && err != KErrAlreadyExists)

            {

            RDebug::Print(_L("Could not add module to list of modules (%d)"), err);

            UiError(_L("Could not add module to list of modules (err)"));

            User::Leave(err);

            }

        //Get added module

        CTestModuleInfo* moduleInfo = iModuleList->GetModule(moduleName);

        if(!moduleInfo)

            {

            RDebug::Print(_L("Could not add get module info from list"));

            UiError(_L("Could not add get module info from list"));

            User::Leave(KErrGeneral);

            }

        //Add ini file if given

        if(iTestModuleIni && iTestModuleIni->Length() > 0)

            {

            TFileName filename;

            filename.Copy(iTestModuleIni->Des());

            filename.LowerCase();

            moduleInfo->SetIniFile(filename);

            }

        //Add config file if given

        if(iTestCaseFile && iTestCaseFile->Length() > 0)

            {

            TFileName filename;

            filename.Copy(iTestCaseFile->Des());

            filename.LowerCase();

            moduleInfo->AddCfgFile(filename);

            }

        //Now check all config files if there are included modules

        _LIT(KIncludeModuleStart, "[New_Include_Module]");

        _LIT(KIncludeModuleEnd, "[End_Include_Module]");

        RDebug::Print(_L("Start parsing included modules"));

        CTestCaseFileInfo* finfo = iModuleList->GetUncheckedCfgFile();

        while(finfo)

            {

            TFileName fname;

            finfo->GetCfgFileName(fname);

            RDebug::Print(_L("Checking file: '%S'"), &fname);

            finfo->SetChecked();

            CStifParser* parser = NULL;

            TRAP(err, parser = CStifParser::NewL(_L(""), fname));

            if(err != KErrNone)

                {

                RDebug::Print(_L("Could not create parser to read content of config file (%d)"), err);

                UiError(_L("Could not create parser to read content of config file (err)"));

                User::Leave(err);

                }

            CleanupStack::PushL(parser);

            ParseTestModulesL(parser, iModuleList, KIncludeModuleStart, KIncludeModuleEnd);

            CleanupStack::PopAndDestroy(parser);

            finfo = iModuleList->GetUncheckedCfgFile();

            }

        RDebug::Print(_L("End parsing included modules"));

        }

    //iConsole->Printf(_L("\nTest Framework starting\n"));

    iConsole.Write(_L("\nTest Framework starting\n"));

    // CUIStore open

    User::LeaveIfError( UIStore().Open( iniFile ) );

    }

/*

-------------------------------------------------------------------------------

    Class: CConsoleMain

    Method: CConsoleMain

    Description: Constructor.

    Initialize non-zero member variables.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Draft

-------------------------------------------------------------------------------

*/

CConsoleMain::CConsoleMain( ):iStartCases( EStartCaseNo )

    {

    }

/*

-------------------------------------------------------------------------------

    Class: CConsoleMain

    Method: ~CConsoleMain

    Description: Destructor

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Draft

-------------------------------------------------------------------------------

*/

CConsoleMain::~CConsoleMain( )

    {	

    iDialogs.ResetAndDestroy();

    iDialogs.Close();

    // CUIStore close

    UIStore().Close();

    delete iReader;

    iReader = NULL;

	delete iScroller;

	iScroller = NULL;

    //delete iConsole;

    //iConsole = NULL;

	if(rConsoleCreated){

		iConsole.Destroy();

	}

    delete iMainMenu;

    iMainMenu = NULL;

    delete iTestModule;

    iTestModule = 0;

    delete iTestModuleIni;

    iTestModuleIni = 0;

    delete iTestCaseFile;

    iTestCaseFile = 0;

    delete iTestSetName;

    iTestSetName = 0;

    delete iModuleList;

    iModuleList = 0;

    iFilters.ResetAndDestroy();

    iFilters.Close();

    }

/*

-------------------------------------------------------------------------------

    Class: CConsoleMain

    Method: ProcessCommandlineL

    Description: Process commandline parameters.

    Parameters: None

    Return Values: None

    Errors/Exceptions: Leaves on error.

    Status: Draft

-------------------------------------------------------------------------------

*/

void CConsoleMain::ProcessCommandlineL( TFileName& aIniFile )

    {

	User me;

    TInt lineLength = me.CommandLineLength();

    HBufC* lineBuf = HBufC::NewLC( lineLength );

    TPtr line( lineBuf->Des() );

    TBool firstTime = ETrue;

    TInt offset = 0;

    TPtrC param;

    TChar c;

    me.CommandLine( line );

    TLex lex( line );

    while( offset < lineLength )

        {    

        // Get first charecter of the parameter

        lex.SkipSpace();

        c = lex.Peek();

        if( c == 0 )

            {

            // End of line

            break;

            }

        // Get the whole parameter 

        param.Set( lex.NextToken() );

        if( firstTime )

            {

            // Filebrowser workaround. It gives the exe name as command line param

            // verify that it is not the same as the executable name

            //@spe TFileName exePath = me.FileName();

			TFileName exePath = RProcess().FileName();

            if ( param == exePath )

                {

                // Discard command line parameters when using filebrowser

                break;

                }

            firstTime = EFalse;

            }

        // Check if -param option

        if( c == '-' )

            {

            // This is option

            if( param == KTestModule )

                {

                // Get test module name

                param.Set( lex.NextToken() );

                if( param.Length() == 0 )

                    {

                    UiError( _L("Test module name not given"));

                    break;

                    }

                if( param.Length() > KMaxName )

                    {

                    UiError( _L("Test module name too long"));

                    break;

                    }

                iTestModule = param.AllocL();

                }

            else if( param == KTestModuleIni )

                {

                // Get test module initialization file

                param.Set( lex.NextToken() );

                if( param.Length() == 0 )

                    {

                    UiError( _L("Test module initialization file name not given"));

                    break;

                    }

                if( param.Length() > KMaxFileName )

                    {

                    UiError( _L("Test module initialization file name too long"));

                    break;

                    }

                TFileName tmpTestModuleIni( param );

                TStifUtil::CorrectFilePathL( tmpTestModuleIni );

                iTestModuleIni = tmpTestModuleIni.AllocL();

                }

            else if( param == KTestCaseFile )

                {

                // Get test case file name

                param.Set( lex.NextToken() );

                if( param.Length() == 0 )

                    {

                    UiError( _L("Test case file name not given"));

                    break;

                    }

                if( param.Length() > KMaxFileName )

                    {

                    UiError( _L("Test case file name too long"));

                    break;

                    }

                TFileName tmpTestCaseFile( param );

                TStifUtil::CorrectFilePathL( tmpTestCaseFile );

                iTestCaseFile = tmpTestCaseFile.AllocL();

                }

            else if( param == KTestSet )

                {

                // Get test set name

                param.Set( lex.NextToken() );

                if( param.Length() == 0 )

                    {

                    UiError( _L("Test set name not given"));

                    break;

                    }

                if( param.Length() > KMaxFileName )

                    {

                    UiError( _L("Test set name too long"));

                    break;

                    }

                iTestSetName = param.AllocL();

                }

            else if( param == KTestRun )

                {

                if( iStartCases )

                    {

                    UiError( _L("Only one -run option allowed") );

                    // Do not start anything

                    iStartCases = EStartCaseNo;

                    break;

                    }

                // Get run type

                lex.Mark();