/*

* Copyright (c) 2010 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 "TestEngineUtils.h"

#include "Logging.h"

#include <StifLogger.h>

#include <StifParser.h>

#include "STIFTestFrameworkSettings.h"

#define LOGGER aLogger

TInt TTestEngineUtils::ParseLoggerDefaults( CStifParser* aParser, TLoggerSettings& aLoggerSettings, CStifLogger* aLogger )

    {

    __TRACE( KInit,( _L( "" ) ) );

    __TRACE( KInit,( _L( "CLoggerSetting::ReadLoggerDefaults" ) ) );

    __TRACE( KInit,( _L( "Start reading and parsing Logger defaults" ) ) );

    TInt ret = KErrNone;

    CSTIFTestFrameworkSettings* settings = NULL;

    TRAPD( settings_ret, settings = CSTIFTestFrameworkSettings::NewL() );

    if ( settings_ret != KErrNone )

        {

        __TRACE( KError,( CStifLogger::ERed, _L( "CSTIFTestFrameworkSettings class object creation fails") ) );

        return settings_ret;

        }

    TInt get_ret( KErrNone );

    CStifSectionParser* sectionParser = NULL;

    // Parse Logger's overwrite values

    _LIT( KDefaultsStart, "[Logger_Defaults]" );

    _LIT( KDefaultsEnd, "[End_Logger_Defaults]" );

    __TRACE( KInit,( _L( "Starting to search sections" ) ) );

    TRAPD( r,

        sectionParser = aParser->SectionL( KDefaultsStart, KDefaultsEnd );

        );

    // Get directory settings

    if ( ( r == KErrNone ) && sectionParser )

        {

        __TRACE( KInit,( _L( "Found '%S' and '%S' sections" ), &KDefaultsStart, &KDefaultsEnd ) );

        __TRACE( KInit,( _L( "Parsing Logger directory indicator" ) ) );

        TBool createDir( EFalse );

        TRAP( get_ret,

            get_ret = settings->GetBooleanSettingsL( sectionParser,

                                _L( "CreateLogDirectories=" ), createDir );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Logger directory indicator: %d"), createDir ) );

            aLoggerSettings.iCreateLogDirectories = createDir;

            aLoggerSettings.iIsDefined.iCreateLogDir = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Indicator not found or not given" ) ) );

            }

        // Get Logger path settings

        __TRACE( KInit,( _L( "Parsing Logger path setting (Emulator)" ) ) );

        TPtrC emulatorPath;

        get_ret = settings->GetFileSetting( sectionParser,

                                               _L( "EmulatorBasePath=" ),

                                               emulatorPath );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Logger base path setting: %S"), &emulatorPath ) );

            aLoggerSettings.iEmulatorPath = emulatorPath;

            aLoggerSettings.iIsDefined.iPath = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Path not found or not given (Emulator)" ) ) );

            }

        // Get Logger format settings

        __TRACE( KInit,( _L( "Parsing Logger file type setting (Emulator)" ) ) );

        CStifLogger::TLoggerType emulatorType = CStifLogger::ETxt;

        TRAP( get_ret, 

            get_ret = settings->GetFormatL( sectionParser,

                                    _L( "EmulatorFormat=" ), emulatorType );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "File type setting: %d"), emulatorType ) );

            aLoggerSettings.iEmulatorFormat = emulatorType;

            aLoggerSettings.iIsDefined.iFormat = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "File type not found or not given (Emulator)" ) ) );

            }

        // Get Logger output settings

        __TRACE( KInit,( _L( "Parsing Logger output setting (Emulator)" ) ) );

        CStifLogger::TOutput emulatorOutput = CStifLogger::EFile;

        TRAP( get_ret,

            get_ret = settings->GetOutputL( sectionParser,

                                    _L( "EmulatorOutput=" ), emulatorOutput );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Output setting: %d"), emulatorOutput ) );

            aLoggerSettings.iEmulatorOutput = emulatorOutput;

            aLoggerSettings.iIsDefined.iOutput = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Output not found or not given (Emulator)" ) ) );

            }

        // Get Logger HW path settings

        __TRACE( KInit,( _L( "Parsing Logger path setting (Hardware)" ) ) );

        TPtrC hwPath;

        get_ret = settings->GetFileSetting( sectionParser,

                                               _L( "HardwareBasePath=" ),

                                               hwPath );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Base path setting: %S"), &hwPath ) );

            aLoggerSettings.iHardwarePath = hwPath;

            aLoggerSettings.iIsDefined.iHwPath = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Path not found or not given (Hardware)" ) ) );

            }

        // Get Logger HW format settings

        __TRACE( KInit,( _L( "Parsing Logger file type setting (Hardware)" ) ) );

        CStifLogger::TLoggerType hwType = CStifLogger::ETxt;

        TRAP( get_ret,

            get_ret = settings->GetFormatL( sectionParser,

                                        _L( "HardwareFormat=" ), hwType );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "File type setting: %d"), hwType ) );

            aLoggerSettings.iHardwareFormat = hwType;

            aLoggerSettings.iIsDefined.iHwFormat = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "File type not found or not given (Hardware)" ) ) );

            }

        // Get Logger HW output settings

        __TRACE( KInit,( _L( "Parsing Logger output setting (Hardware)" ) ) );

        CStifLogger::TOutput hwOutput = CStifLogger::EFile;

        TRAP( get_ret, 

        get_ret = settings->GetOutputL( sectionParser,

                                    _L( "HardwareOutput=" ), hwOutput );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Output setting: %d"), hwOutput ) );

            aLoggerSettings.iHardwareOutput = hwOutput;

            aLoggerSettings.iIsDefined.iHwOutput = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Output not found or not given (Hardware)" ) ) );

            }

        // Get Logger file creation mode (overwrite settings)

        __TRACE( KInit,( _L( "Parsing file creation setting" ) ) );

        TBool overwrite( ETrue );

        TRAP( get_ret,

            get_ret = settings->GetOverwriteL( sectionParser,

                                _L( "FileCreationMode=" ), overwrite );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "File creation mode setting: %d"), overwrite ) );

            aLoggerSettings.iOverwrite = overwrite;

            aLoggerSettings.iIsDefined.iOverwrite = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "File creation not found or not given" ) ) );

            }

        // Get Time stamp settings

        __TRACE( KInit,( _L( "Parsing time stamp setting" ) ) );

        TBool timeStamp( ETrue );

        TRAP( get_ret,

            get_ret = settings->GetBooleanSettingsL( sectionParser,

                                _L( "WithTimeStamp=" ), timeStamp );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Time stamp setting: %d"), timeStamp ) );

            aLoggerSettings.iTimeStamp = timeStamp;

            aLoggerSettings.iIsDefined.iTimeStamp = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Time stamp not found or not given" ) ) );

            }

        // Get Test report line break settings

        __TRACE( KInit,( _L( "Parsing line break setting" ) ) );

        TBool lineBreak( ETrue );

        TRAP( get_ret,

            get_ret = settings->GetBooleanSettingsL( sectionParser,

                                _L( "WithLineBreak=" ), lineBreak );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Line break setting: %d"), lineBreak ) );

            aLoggerSettings.iLineBreak = lineBreak;

            aLoggerSettings.iIsDefined.iLineBreak = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Line break not found or not given" ) ) );

            }

        // Get Test report event ranking settings

        __TRACE( KInit,( _L( "Parsing event ranking setting" ) ) );

        TBool eventRanking( EFalse );

        TRAP( get_ret,

            get_ret = settings->GetBooleanSettingsL( sectionParser,

                            _L( "WithEventRanking=" ), eventRanking );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Event ranking setting: %d"), eventRanking ) );

            aLoggerSettings.iEventRanking = eventRanking;

            aLoggerSettings.iIsDefined.iEventRanking = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Event ranking not found or not given" ) ) );

            }

        // Get Test report thread id settings

        __TRACE( KInit,( _L( "Parsing thread id setting" ) ) );

        TBool threadId( EFalse );

        TRAP( get_ret,

            get_ret = settings->GetBooleanSettingsL( sectionParser,

                                    _L( "ThreadIdToLogFile=" ), threadId );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Thread id setting: %d"), threadId ) );

            aLoggerSettings.iThreadId = threadId;

            aLoggerSettings.iIsDefined.iThreadId = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Thread id not found or not given" ) ) );

            }

        // Get unicode setting

        __TRACE( KInit,( _L( "Parsing unicode setting" ) ) );

        TBool unicode(EFalse);

        TRAP( get_ret,

            get_ret = settings->GetBooleanSettingsL( sectionParser,

                                    _L( "FileUnicode=" ), unicode );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Unicode setting: %d"), unicode ) );

            aLoggerSettings.iUnicode = unicode;

            aLoggerSettings.iIsDefined.iUnicode = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Unicode setting not found or not given" ) ) );

            }

        // Check if test case title should be added to log file name

        __TRACE( KInit,( _L( "Parsing AddTestCaseTitle setting" ) ) );

        TBool addTestCaseTitle(EFalse);

        TRAP(get_ret,

            get_ret = settings->GetBooleanSettingsL(sectionParser,

                                    _L( "AddTestCaseTitle=" ), addTestCaseTitle);

            );

        if(get_ret == KErrNone)

            {

            __TRACE( KInit,( _L( "AddTestCaseTitle setting: %d"), addTestCaseTitle));

            aLoggerSettings.iAddTestCaseTitle = addTestCaseTitle;

            aLoggerSettings.iIsDefined.iAddTestCaseTitle = ETrue;

            }

        else

            {

            __TRACE(KInit, (_L("AddTestCaseTitle setting not found or not given")));

            }

        }

    else

        {

        __TRACE( KInit,( _L( "Not found '%S' and '%S' sections" ), &KDefaultsStart, &KDefaultsEnd ) );

        ret = KErrNotFound;

        }

    __TRACE( KInit,( _L( "End reading and parsing Logger defaults" ) ) );

    __TRACE( KInit,( _L( "" ) ) );

    delete sectionParser;

    delete settings;

    return ret;

    }

// End of file