/*
 * 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 Files  

#include "STFLogger.h"	// RSTFLogger
#include "STFLoggerCSCommon.h"
#include "STFLoggerOverFlow.h"
#include <hal.h> 
#include "SettingServerClient.h"

// Runs client-side and starts the separate server process
static TInt StartTheServer()
    {

    //Ccheck server not already started
    TFindServer findServer(KSTFLoggerServerBinaryName);
    TFullName name;
    if (findServer.Next(name) == KErrNone)
        {
        return KErrAlreadyExists;
        }
    RProcess server;
    TInt r = server.Create(KSTFLoggerServerBinaryName, KNullDesC);
    if (r != KErrNone)
        return r;

    TRequestStatus stat;
    server.Rendezvous(stat);
    if (stat != KRequestPending)
        server.Kill(0); // abort startup
    else
        server.Resume(); // logon OK - start the server

    User::WaitForRequest(stat); // wait for start or death

    // Check the exit type.
    // We can't use the 'exit reason' because if the server panicked this
    // is set to the panic 'reason' (which may be '0' and cannot thus be distinguished
    // from KErrNone)
    r = server.ExitType();
    if (EExitPanic == r)
        r = KErrGeneral;
    else
        r = stat.Int();

    server.Close(); // This is no longer needed
    return r;
    }

//  Member Functions
EXPORT_C TInt RSTFLogger::Connect()
    {
    TInt retry = 2;
    for (;;)
        {// Uses system-pool message slots
        TInt r = CreateSession(KSTFLoggerServerName, TVersion(1, 0, 0));
        if ((KErrNotFound != r) && (KErrServerTerminated != r))
            return (r);
        if (--retry == 0)
            return (r);
        r = StartTheServer();
        if ((KErrNone != r) && (KErrAlreadyExists != r))
            return (r);
        }
    }

EXPORT_C TInt RSTFLogger::CreateL(const TDesC& aTestPath,
        const TDesC& aTestFile, CStifLogger::TLoggerType aLoggerType,
        CStifLogger::TOutput aOutput, TBool aOverWrite, TBool aWithTimeStamp,
        TBool aWithLineBreak, TBool aWithEventRanking,
        TBool aThreadIdToLogFile, TBool aCreateLogDir,
        TInt aStaticBufferSize, TBool aUnicode)
    {
    if( KMaxName < aTestPath.Length() || KMaxName < aTestFile.Length() )
        {
        User::Leave( KErrArgument );
        }
    
    // Handle to Setting server.
    RSettingServer settingServer;
    // Connect to the Setting server and create session
    TInt ret = settingServer.Connect();
    if (ret != KErrNone)
        {
        settingServer.Close();
        return ret;
        }
    // Struct to StifLoggerBase settigs.
    TLoggerSettings loggerSettings;
    // Parse StifLoggerBase defaults from STIF initialization file.
    ret = settingServer.GetLoggerSettings(loggerSettings);
    settingServer.Close();
    if (ret != KErrNone)
        {
        return ret;
        }

    TName testPath = aTestPath;
    TName testFile = aTestFile;

    // Take in use the overwrite parameters
    OverwriteLoggerSettings(loggerSettings, testPath, testFile, aLoggerType,
            aOutput, aOverWrite, aWithTimeStamp, aWithLineBreak,
            aWithEventRanking, aThreadIdToLogFile, aCreateLogDir, aUnicode);
    
    RThread threadHandle;                   // A handle to a thread
    TThreadId id = threadHandle.Id();       // Encapsulates the Id of a thread

    TSTFLoggerCreateData loggerData(testPath, testFile, aLoggerType, aOutput,
            aOverWrite, aWithTimeStamp, aWithLineBreak, aWithEventRanking,
            aThreadIdToLogFile, aCreateLogDir, aStaticBufferSize, aUnicode, (TInt)id);
    TPckg<TSTFLoggerCreateData> data(loggerData);
    TIpcArgs args(&data);
    return (SendReceive(ESTFLogger_CreateLogger, args));
    }



EXPORT_C TInt RSTFLogger::CreateL(const TDesC& aTestPath,
        const TDesC& aTestFile, TLoggerSettings& aLoggerSettings)
    {
    TSTFLoggerCreateData loggerData;
    loggerData.iTestPath = aTestPath;
    loggerData.iTestFile = aTestFile;
    loggerData.iOverWrite = aLoggerSettings.iOverwrite;
    loggerData.iWithTimeStamp = aLoggerSettings.iTimeStamp;
    loggerData.iWithLineBreak = aLoggerSettings.iLineBreak;
    loggerData.iWithEventRanking = aLoggerSettings.iEventRanking;
    loggerData.iThreadIdToLogFile = aLoggerSettings.iThreadId;
    loggerData.iCreateLogDir = aLoggerSettings.iCreateLogDirectories;
    loggerData.iStaticBufferSize = 0;
    loggerData.iUnicode = aLoggerSettings.iUnicode;
    TInt cpu(0);
    HAL::Get(HALData::ECPU, cpu);

    // HW environment
    if (cpu == HALData::ECPU_ARM)
        {
        loggerData.iOutput = aLoggerSettings.iHardwareOutput;
        loggerData.iLoggerType = aLoggerSettings.iHardwareFormat;
        } // End of HW environment branch

    // Wins environment ( cpu == HALData::ECPU_X86 )
    else
        {
        loggerData.iOutput = aLoggerSettings.iEmulatorOutput;
        loggerData.iLoggerType = aLoggerSettings.iEmulatorFormat;
        } // End of WINS environment branch
    
    RThread threadHandle;                   // A handle to a thread
    TThreadId id = threadHandle.Id();       // Encapsulates the Id of a thread
    
    loggerData.iThreadId = (TInt)id;

    TPckg<TSTFLoggerCreateData> data(loggerData);
    TIpcArgs args(&data);
    return (SendReceive(ESTFLogger_CreateLogger, args));
    }

EXPORT_C TInt RSTFLogger::Log(const TDesC& aLogInfo)
    {
    return (Log(CStifLogger::ENoStyle, aLogInfo));
    }

EXPORT_C TInt RSTFLogger::Log(const TDesC8& aLogInfo)
    {
    return (Log(CStifLogger::ENoStyle, aLogInfo));
    }

EXPORT_C TInt RSTFLogger::Log(TInt aStyle, const TDesC& aLogInfo)
    {
    TIpcArgs args(aLogInfo.Length(), aStyle, &aLogInfo);
    return (SendReceive(ESTFLogger_Log_TInt_TDesC, args));
    }

EXPORT_C TInt RSTFLogger::Log(TInt aStyle, const TDesC8& aLogInfo)
    {
    TIpcArgs args(aLogInfo.Length(), aStyle, &aLogInfo);
    return (SendReceive(ESTFLogger_Log_TInt_TDesC8, args));
    }

EXPORT_C TInt RSTFLogger::Log(TRefByValue<const TDesC> aLogInfo, ...)
    {
    VA_LIST list;
    VA_START( list, aLogInfo );
    TLogInfo logInfo;

    // Create overflow handler. If the log information size is over the
    // KMaxLogData rest of the information will cut.
    TDesSTFLoggerOverflowHandler overFlowHandler(this, 1);

    // Parse parameters
    logInfo.AppendFormatList(aLogInfo, list, &overFlowHandler);

    // No text style info

    return Log(CStifLogger::ENoStyle, logInfo);
    }

EXPORT_C TInt RSTFLogger::Log(TRefByValue<const TDesC8> aLogInfo, ...)
    {
    VA_LIST list;
    VA_START( list, aLogInfo );
    TLogInfo8 logInfo;

    // Create overflow handler. If the log information size is over the
    // KMaxLogData rest of the information will cut.
    TDes8STFLoggerOverflowHandler overFlowHandler(this, 1);

    // Parse parameters
    logInfo.AppendFormatList(aLogInfo, list, &overFlowHandler);

    // No text style info
    return Log(CStifLogger::ENoStyle, logInfo);
    }

EXPORT_C TInt RSTFLogger::Log(TInt aStyle, TRefByValue<const TDesC> aLogInfo,
        ...)
    {
    VA_LIST list;
    VA_START( list, aLogInfo );
    TLogInfo logInfo;

    // Create overflow handler. If the log information size is over the
    // KMaxLogData rest of the information will cut.
    TDesSTFLoggerOverflowHandler overFlowHandler(this, 2);

    // Parse parameters
    logInfo.AppendFormatList(aLogInfo, list, &overFlowHandler);

    return Log(aStyle, logInfo);
    }

EXPORT_C TInt RSTFLogger::Log(TInt aStyle,
        TRefByValue<const TDesC8> aLogInfo, ...)
    {
    VA_LIST list;
    VA_START( list, aLogInfo );
    TLogInfo8 logInfo;

    // Create overflow handler. If the log information size is over the
    // KMaxLogData rest of the information will cut.
    TDes8STFLoggerOverflowHandler overFlowHandler(this, 2);

    // Parse parameters
    logInfo.AppendFormatList(aLogInfo, list, &overFlowHandler);

    return Log(aStyle, logInfo);
    }

EXPORT_C TInt RSTFLogger::WriteDelimiter(const TDesC& aDelimiter, TInt aCount)
    {
    TLogInfo delimiter;

    // Create overflow handler. If the delimiter size expands over the
    // KMaxLogData the TDesLoggerOverflowHandler will call.
    TDesSTFLoggerOverflowHandler overFlowHandler(this, 3);

    // Create a delimiter
    for (TInt a = 0; a < aCount; a++)
        {
        // If delimiter creation keeps under the KMaxLogData.
        // If not we use TDesLoggerOverflowHandler.
        if ((a * aDelimiter.Length()) < KMaxLogData)
            {
            delimiter.Append(aDelimiter);
            }
        // KMaxLogData is exceeded
        else
            {
            // If the title size is over the KMaxLogData default delimiter will
            // use. Use normal overflowhandler to print overflow information.
            TBuf<4> empty; // Not really used.
            overFlowHandler.Overflow(empty);
            delimiter.Copy(
                    _L( "##################################################" ));
            break;
            }
        }

    // No text style info
    return Log(CStifLogger::ENoStyle, delimiter);
    }

EXPORT_C TInt RSTFLogger::WriteDelimiter(const TDesC8& aDelimiter,
        TInt aCount)
    {
    TLogInfo8 delimiter;

    // Create overflow handler. If the delimiter size expands over the
    // KMaxLogData the TDesLoggerOverflowHandler will call.
    TDes8STFLoggerOverflowHandler overFlowHandler(this, 3);

    // Create a delimiter
    for (TInt a = 0; a < aCount; a++)
        {
        // If delimiter creation keeps under the KMaxLogData.
        // If not we use TDesLoggerOverflowHandler.
        if ((a * aDelimiter.Length()) < KMaxLogData)
            {
            delimiter.Append(aDelimiter);
            }
        // KMaxLogData is exceeded
        else
            {
            // If the title size is over the KMaxLogData default delimiter will
            // use. Use normal overflowhandler to print overflow information.
            TBuf8<4> empty; // Not really used.
            overFlowHandler.Overflow(empty);
            delimiter.Copy(
                    _L8( "##################################################" ));
            break;
            }
        }

    // No text style info
    return Log(CStifLogger::ENoStyle, delimiter);
    }

EXPORT_C TInt RSTFLogger::SaveData(const TDesC& aData)
    {
    return Log(CStifLogger::ENoStyle, aData);
    }

EXPORT_C TInt RSTFLogger::SaveData(const TDesC8& aData)
    {
    return Log(CStifLogger::ENoStyle, aData);
    }

EXPORT_C TInt RSTFLogger::CreationResult(TInt& aResult)
    {
    TPckg<TInt> data(aResult);
    TIpcArgs args(&data);
    return (SendReceive(ESTFLogger_CreationResult, args));
    }

EXPORT_C TInt RSTFLogger::OutputType(CStifLogger::TOutput& aOutputType)
    {
    TPckg<CStifLogger::TOutput> data(aOutputType);
    TIpcArgs args(&data);
    return (SendReceive(ESTFLogger_OutputType, args));
    }

void RSTFLogger::OverwriteLoggerSettings(TLoggerSettings& aLoggerSettings,
        TName& aTestPath, TName& aTestFile,
        CStifLogger::TLoggerType& aLoggerType, CStifLogger::TOutput& aOutput,
        TBool& aOverWrite, TBool& aWithTimeStamp, TBool& aWithLineBreak,
        TBool& aWithEventRanking, TBool& aThreadIdToLogFile,
        TBool& aCreateLogDir, TBool& aUnicode)
    {
    // Which environment is in use
    TInt cpu(0);

    // Indicator is file type remove acceptable operation
    TBool removeFileType(EFalse);

    // Get environment
    HAL::Get(HALData::ECPU, cpu);

    // HW environment
    if (cpu == HALData::ECPU_ARM)
        {
        TInt pathLen = aTestPath.Length()
                + aLoggerSettings.iHardwarePath.Length();

        // Check that path overwrite setting is defined and length is legal
        if (aLoggerSettings.iIsDefined.iHwPath && pathLen < KMaxName)
            {
            TName newPath;
            newPath = aLoggerSettings.iHardwarePath;
            // Check is '\' the last character
            TInt ret(0);
            ret = newPath.LocateReverse(92);
            // Is '\' character founded
            if (ret != KErrNotFound)
                {
                // Is '\' last character
                if (ret == (newPath.Length() - 1))
                    {
                    // delete last '\'
                    newPath.Delete((aLoggerSettings.iHardwarePath.Length()
                            - 1), 1);
                    }
                }
            // Removes drive letter if given and appends implemented path 
            TParse parse;
            parse.Set(aTestPath, NULL, NULL);
            // Path() return value starts with '\'
            newPath.Append(parse.Path());
            aTestPath = newPath;
            }
        if (aLoggerSettings.iIsDefined.iHwFormat)
            {
            aLoggerType = aLoggerSettings.iHardwareFormat;
            // Remove file type if it is set
            removeFileType = ETrue;
            }
        if (aLoggerSettings.iIsDefined.iHwOutput)
            {
            aOutput = aLoggerSettings.iHardwareOutput;
            }
        }

    // Wins environment ( cpu == HALData::ECPU_X86 )
    else
        {
        TInt pathLen = aTestPath.Length()
                + aLoggerSettings.iEmulatorPath.Length();

        // Check that path overwrite setting is defined and length is legal
        if (aLoggerSettings.iIsDefined.iPath && pathLen < KMaxName)
            {
            TName newPath;
            newPath = aLoggerSettings.iEmulatorPath;
            // Check is '\' the last character
            TInt ret(0);
            ret = newPath.LocateReverse(92);
            // Is '\' character founded
            if (ret != KErrNotFound)
                {
                // Is '\' last character
                if (ret == (newPath.Length() - 1))
                    {
                    // delete last '\'
                    newPath.Delete((aLoggerSettings.iEmulatorPath.Length()
                            - 1), 1);
                    }
                }
            // Removes drive letter if given and appends implemented path
            TParse parse;
            parse.Set(aTestPath, NULL, NULL);
            // Path() return value starts with '\'
            newPath.Append(parse.Path());
            aTestPath = newPath;
            }
        if (aLoggerSettings.iIsDefined.iFormat)
            {
            aLoggerType = aLoggerSettings.iEmulatorFormat;
            // Remove file type if it is set
            removeFileType = ETrue;
            }
        if (aLoggerSettings.iIsDefined.iOutput)
            {
            aOutput = aLoggerSettings.iEmulatorOutput;
            }
        }

    // Rest of the overwrite values
    if (aLoggerSettings.iIsDefined.iOverwrite)
        {
        aOverWrite = aLoggerSettings.iOverwrite;
        }
    if (aLoggerSettings.iIsDefined.iTimeStamp)
        {
        aWithTimeStamp = aLoggerSettings.iTimeStamp;
        }
    if (aLoggerSettings.iIsDefined.iLineBreak)
        {
        aWithLineBreak = aLoggerSettings.iLineBreak;
        }
    if (aLoggerSettings.iIsDefined.iEventRanking)
        {
        aWithEventRanking = aLoggerSettings.iEventRanking;
        }
    if (aLoggerSettings.iIsDefined.iThreadId)
        {
        aThreadIdToLogFile = aLoggerSettings.iThreadId;
        }
    if (aLoggerSettings.iIsDefined.iCreateLogDir)
        {
        aCreateLogDir = aLoggerSettings.iCreateLogDirectories;
        }
    if (aLoggerSettings.iIsDefined.iUnicode)
        {
        aUnicode = aLoggerSettings.iUnicode;
        }

    // Remove file type if allowed and if file type is set to filename
    if (removeFileType)
        {
        // Remove file type '.XXX' from file name if exist
        if (aTestFile.Find(_L( "." )))
            {
            TParse parse;
            parse.Set(aTestFile, NULL, NULL);
            // Type length
            TInt length(0);
            // '.XXX'
            length = parse.Ext().Length();
            // Delete type
            aTestFile.Delete(aTestFile.Length() - length, length);
            }
        }

    }