// Copyright (c) 2007-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 <iostream>

#include <sstream>

#include <string>

#include <windows.h>

#include "utracedecoderapp.h"

#include "utraceframe.h"

#include "framesorter.h"

#include "util.h"

#include "logevents\traceeventbase.h"

#include "version.h"

const int KLogBufferSize = 16384;

Parser::CDefinitionParser* gMsgDefParser;

bool gQuiet;

bool CUTraceDecoderApp::iUseTimes = false;

CUTraceDecoderApp::TTimestampPeriod CUTraceDecoderApp::iPeriodType = CUTraceDecoderApp::EUnknown;

double CUTraceDecoderApp::iPeriod1;

double CUTraceDecoderApp::iPeriod2;

CUTraceDecoderApp::CUTraceDecoderApp()

    {

    iFrameSorter = new CFrameSorter(*this);

    iDumpIdentifiers = false;

    iTesting = false;

    SetShowContextInfo(true);

    iCurrentFrame = 0;

    iUseQuotes = false;

    iTail = false;

    iInputBuffer = new unsigned char[KLogBufferSize];

    iBufferOffset = 0;

    iBufferSize = 0;

    iBufferValid = false;

    // There will only ever be one CUTraceDecoderApp so this isn't so bad

    // Needs refactoring though. gMsgDefParser is used by the Node Message Event

    ::gMsgDefParser = new Parser::CDefinitionParser();

	::gQuiet = false;

    }

CUTraceDecoderApp::~CUTraceDecoderApp()

    {

    delete iInputBuffer;

    }

bool CUTraceDecoderApp::Initialise(int aArgc, char **aArgv) 

    {

    if (aArgc < 2)

	    {

	    return false;

	    }

    // defaults

    SetShowContextInfo(true);

    SetNewLineEnabled(true);

    int currentArg = 1;

    while (currentArg < aArgc)

        {

        if (aArgv[currentArg][0] == '-' && aArgv[currentArg][1] == '-')

            {

            if (!_strcmpi(&aArgv[currentArg][2], "payload-only"))

                {

                SetShowContextInfo(false);

                }

            else if (!_strcmpi(&aArgv[currentArg][2], "use-quotes"))

                {

                iUseQuotes = true;

                }

            else if (!_strcmpi(&aArgv[currentArg][2], "use-times"))

                {

                iUseTimes = true;

                }

            else if (!_strcmpi(&aArgv[currentArg][2], "tail"))

                {

                // EXPERIMENTAL: This is an experimental feature at the moment

                iTail = true;

                }

			else if (!_strcmpi(&aArgv[currentArg][2], "quiet"))

				{

				::gQuiet = true;

				}

            else if (!_strcmpi(&aArgv[currentArg][2], "message-def"))

                {

                currentArg++;

                iMsgDefFile = aArgv[currentArg];

                }

            else if (!_strcmpi(&aArgv[currentArg][2], "dump-frame"))

                {

                currentArg++;

                char* startFrame = aArgv[currentArg];

                char* endFrame = startFrame;

                while (*endFrame != ',' && *endFrame != 0)

                    {

                    if (*endFrame < '0' || *endFrame > '9')

                        {

                        return false;

                        }

                    ++endFrame;

                    }

                if (*endFrame == 0)

                    {

                    return false;

                    }

                *endFrame = 0;

                if (*startFrame == 0)

                    {

                    return false;

                    }

                ++endFrame;

                char* tmp = endFrame;

                while (*tmp != 0)

                    {

                    if (*tmp < '0' || *tmp > '9')

                        {

                        return false;

                        }

                    ++tmp;

                    }

                iFrameSorter->SetDumpFrameRange(atol(startFrame), atol(endFrame));

                }

            else if (!_strcmpi(&aArgv[currentArg][2], "dump-event"))

                {

                currentArg++;

                char* startEvent = aArgv[currentArg];

                char* endEvent = startEvent;

                while (*endEvent != ',' && *endEvent != 0)

                    {

                    if (*endEvent < '0' || *endEvent > '9')

                        {

                        return false;

                        }

                    ++endEvent;

                    }

                if (*endEvent == 0)

                    {

                    return false;

                    }

                *endEvent = 0;

                if (*startEvent == 0)

                    {

                    return false;

                    }

                ++endEvent;

                char* tmp = endEvent;

                while (*tmp != 0)

                    {

                    if (*tmp < '0' || *tmp > '9')

                        {

                        return false;

                        }

                    ++tmp;

                    }

                iFrameSorter->SetDumpEventRange(atol(startEvent), atol(endEvent));

                }

            else if (!_strcmpi(&aArgv[currentArg][2], "dump-message-def"))

                {

                iDumpIdentifiers = true;

                }

            else if (!_strcmpi(&aArgv[currentArg][2], "test-message-def"))

                {

                iTesting = true;

                }

            }

        else

            {

            if (iLogFile.length() > 0)

                {

                return false;

                }

            iLogFile = aArgv[currentArg];

            }

        currentArg++;

        }

    if (iMsgDefFile.length() > 0)

        {

        if (iTesting)

            {

            gMsgDefParser->SetTestMode();

            }

        if (gMsgDefParser->ParseDefinitionFile(iMsgDefFile.c_str()) != Parser::ENoError)

            {

//            std::cerr << "Error in message definition file" << std::endl;

            return false;

            }

        }

    if (iDumpIdentifiers)

        {

        gMsgDefParser->DumpIdentifiers();

        }

    if (iTesting)

        {

        if (iMsgDefFile.length() == 0)

            {

            std::cerr << "No message definition file specifed to check" << std::endl;

            }

        return true;

        }

    if (iLogFile.length() == 0)

        {

        return false;

        }

    return true;

    }

void CUTraceDecoderApp::ProcessLog()

    {

    // csv header

    if (ShowContextInfo())

        {

        std::cout << "Sequence,Primary Filter,Sub Category,Time Stamp1,Time Stamp2,Context ID,Description" << std::endl;

        } 

    // Open the log file and fill the buffer

    if(!LoadUTraceLog()) 

        { // file couldn't be opened

        std::cerr << "Error: file " << iLogFile.c_str() << " could not be opened." << std::endl;

        return;

        }

    while (iBufferValid)

        {

        while (iBufferOffset < iBufferSize)

            {

            //grab a hunk of log

            int length = iInputBuffer[iBufferOffset];

            length = (length + 3) & ~3;

            // Minimum length is actually 4, but this would mean only the header was

            // present, so why was it logged

            if (length < 8 || length > KMaxBTraceRecordSize)

                {

                if (!iInputFile.eof())

                    {

                    std::cerr << "Error: Frame " << iCurrentFrame << " is corrupt - size is out of range (8-116)" << std::endl;

                    // Dump what we have in the buffer, up to the max size of a frame

                    DumpBytes(std::cerr, &iInputBuffer[iBufferOffset], (KMaxBTraceRecordSize < (iBufferSize - iBufferOffset)) ? KMaxBTraceRecordSize : (iBufferSize - iBufferOffset));

                    }

                return;

                }

            if (length + iBufferOffset > iBufferSize)

                {

                break;

                }

            CUTraceFrame* frame = new CUTraceFrame(&iInputBuffer[iBufferOffset], iCurrentFrame);

            if (frame)

                {

                iFrameSorter->ProcessFrame(frame);

                frame = NULL;

                iCurrentFrame++;

                }

            else

                {

                std::cerr << "Failed to create frame instance" << std::endl;

                }

            iBufferOffset += length;

            }

        RefillUTraceBuffer();

        }

    iInputFile.close();

	std::cerr << "Processed " << iCurrentFrame << " frames" << std::endl;

    }

unsigned int CUTraceDecoderApp::CurrentFrame() const

    {

    return iCurrentFrame;

    }

void CUTraceDecoderApp::WriteEvent(const CTraceEventBase& aEvent) const

    {

    if (NewLineEnabled())

        {

        if (ShowContextInfo())

            {

            aEvent.WriteContextInfo(std::cout);

            }

        if (iUseQuotes)

            {

            std::cout << "\"";

            }

        aEvent.WriteEventPrefix(std::cout);

        }

    if (iUseQuotes)

        {

        std::stringstream ss;

        aEvent.Describe(ss);

        std::string s = ss.str();

        // todo: replace " with ""

        std::cout << s;

        }

    else

        {

        aEvent.Describe(std::cout);

        }

    if (NewLineEnabled())

        {

        if (iUseQuotes)

            {

            std::cout << "\"";

            }

        std::cout << std::endl;

        }

    else

        {

        std::cout << " ";

        }

    };

bool CUTraceDecoderApp::LoadUTraceLog()

    {

    iInputFile.open(iLogFile.c_str(), std::ios::in | std::ios::binary);

    if (iInputFile.is_open())

        {

        RefillUTraceBuffer();

        return true;

        }

    return false;

    }

void CUTraceDecoderApp::RefillUTraceBuffer()

    {

    int bufferSpace = KLogBufferSize;

    int bufferInUse = 0;

    if (iBufferOffset)

        {

        bufferInUse = iBufferSize - iBufferOffset;

        bufferSpace = KLogBufferSize - bufferInUse;

        memcpy(iInputBuffer, &iInputBuffer[iBufferOffset], bufferInUse);

        }

    memset(&iInputBuffer[bufferInUse], 0, bufferSpace);

    iInputFile.read((char*)&iInputBuffer[bufferInUse], bufferSpace);

    iBufferSize = iInputFile.gcount();

#ifdef _DEBUG

    std::cerr << std::dec << std::noshowbase << iBufferSize << " bytes read from log file" << std::endl;

#endif

    iBufferValid = (iBufferSize > 0);

    if (!iBufferValid && iTail)

        {

        // EXPERIMENTAL: This is an experimental feature at the moment

        HANDLE fileChangeHandle;

        fileChangeHandle = FindFirstChangeNotificationA(iLogFile.c_str(), FALSE, FILE_NOTIFY_CHANGE_SIZE);

        if (fileChangeHandle != INVALID_HANDLE_VALUE)

            {

            iInputFile.read((char*)&iInputBuffer[bufferInUse], bufferSpace);

            iBufferSize = iInputFile.gcount();

            std::cerr << std::dec << std::noshowbase << iBufferSize << " bytes read from log file" << std::endl;

            iBufferValid = (iBufferSize > 0);

            FindCloseChangeNotification(fileChangeHandle);

            }

        }

    iBufferSize += bufferInUse;

    iBufferOffset = 0;

    }

void CUTraceDecoderApp::ShowUsage()

    {

	std::cerr

        << "utracedecoder " APPVERSION ":" << std::endl

	    << "Log parser for utrace logs, converts a utrace generated log file into human readable and perl processable csv format" << std::endl

	    << "utracedecoder [options] <path_to_log>" << std::endl

        << "    --payload-only                 Show only the message part of the trace" << std::endl

        << "    --use-quotes                   Wrap the description in quotes" << std::endl

        << "    --use-times                    \"time-in-seconds,0\" substituted for \"timestamp1,timestamp\" pair" << std::endl

        << "    --message-def <message_definition_file>  The file from which to load message and signature definition" << std::endl

        << "    --test-message-def             Tests the message definition file showing all errors then exits" << std::endl

        << std::endl << "Debugging options" << std::endl 

        << "    --dump-message-def             Dumps the parsed definition file details" << std::endl

        << "    --dump-frame <start_frame>,<end_frame>  Dumps the frames in the given range to stderr" << std::endl

        << "    --dump-event <first_event>,<last_event>  Dumps the events in the given range to stderr" << std::endl

		<< "    --quiet                        Only output urgent warnings" << std::endl

        << std::endl;

    }

void CUTraceDecoderApp::SetTimestampPeriod(CUTraceDecoderApp::TTimestampPeriod aType, double aPeriod1, double aPeriod2)

	{

	iPeriodType = aType;

	iPeriod1 = aPeriod1;

	iPeriod2 = aPeriod2;

	}