// 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 <string>

#include <iostream>

#include <sstream>

#include <iomanip>

#include "utracedecoderapp.h"

#include "logevents\nodemessageevent.h"

#include "messagedefparser\definitionparser.h"

#include "messagedefparser\signatureidentifier.h"

#include "messagedefparser\contextidentifier.h"

#include "messagedefparser\messageidentifier.h"

CNodeMessageEvent::CNodeMessageEvent(const CUTraceFrame& aFrame, MEventOutputHandler& aOutputHandler)

    : CSimpleLogEvent(aFrame, aOutputHandler)

    {

    SetPrefix("ENodeMessages");

    }

CNodeMessageEvent::CNodeMessageEvent(const CMultiPartFrameCollection& aFrameCollection, MEventOutputHandler& aOutputHandler)

    : CSimpleLogEvent(aFrameCollection, aOutputHandler)

    {

    SetPrefix("ENodeMessages");

    }

void CNodeMessageEvent::Describe(std::ostream& aOutput) const

    {

    unsigned char* payload = Data();

    unsigned int length = DataLength();

    unsigned int subCategory = SubCategory();

    unsigned int textLength = Arg1();

    if (subCategory == ELogMessage || subCategory == ELogAddress || subCategory == ELogNode)

        {

        if (textLength > length)

            {

            aOutput << "**** ERROR: Corrupt event. Embedded text length > Event length **** ";

            return;

            }

        if (textLength > 0)

            {

            std::string embeddedText = std::string(reinterpret_cast<char*>(Data())).substr(0, textLength);

            aOutput << embeddedText << " ";

            payload += textLength;

            length -= textLength;

            }

        if (length <= 0)

            {

            aOutput << "**** ERROR: Corrupt event. No data after embedded text **** ";

            return;

            }

        }

    switch (subCategory)

        {

        case ELogMessage:

            {

            const SMessageHeader& header = *reinterpret_cast<const SMessageHeader*>(payload);

            const Parser::CSignatureIdentifier* msgSig = ::gMsgDefParser->FindSignatureByTypeId(header.iTypeId);

            if (msgSig)

                {

                aOutput << "[Signature=" + std::string(msgSig->Name()) + "] ";

                //if (msgSig->IsNodeSignalDerived())

                //    {

                //    const TMessageId& msgId = *reinterpret_cast<const TMessageId*>(payload + header.iLength - sizeof(TMessageId));

                //    const Parser::CMessageIdentifier* msg = ::gMsgDefParser->FindMessageByMessageId(msgId);

                //    if (msg)

                //        {

                //        aOutput << "[Message=" + std::string(msg->Name()) + "] ";

                //        }

                //    }

                if (header.iLength - sizeof(header) == msgSig->TotalSize())

                    {

                    msgSig->Describe(payload + sizeof(header), header.iLength - sizeof(header), NULL, aOutput);

                    }

                else

                    {

                    aOutput << "**** ERROR: Corrupt event or incorrect signature definition - "

                        << "[Signature=0x" << std::noshowbase << std::setw(8) << std::setfill('0')

                        << std::nouppercase << std::hex << header.iTypeId.iUid

                        << ":0x" << std::noshowbase << std::setw(8) << std::setfill('0')

                        << std::nouppercase << std::hex << header.iTypeId.iType << "] **** ";

                    }

                }

            else

                {

                aOutput << "**** ERROR: Undefined signature - [Signature=0x"

                    << std::noshowbase << std::setw(8) << std::setfill('0') << std::nouppercase << std::hex << header.iTypeId.iUid

                    << ":0x"

                    << std::noshowbase << std::setw(8) << std::setfill('0') << std::nouppercase << std::hex << header.iTypeId.iType

                    << "] **** ";

                }

            }

            break;

        case ELogBlockStart:

            EventOutputHandler().PushNewLineEnabled(false);

            aOutput << "[STARTBLOCK=";

            CSimpleLogEvent::DescribeText(aOutput);

            aOutput << "] ";

            break;

        case ELogBlockEnd:

            aOutput << "[ENDBLOCK=";

            CSimpleLogEvent::DescribeText(aOutput);

            aOutput << "] ";

            EventOutputHandler().PopNewLineEnabled();

            break;

        case ELogNodeCreate:

        case ELogNodeDestroy:

        case ELogInfo:

            CSimpleLogEvent::DescribeText(aOutput);

            break;

        case ELogAddress:

            {

            const SRuntimeContextBase& rtCtx = *reinterpret_cast<const SRuntimeContextBase*>(payload);

            if (rtCtx.iSize & 0x80) // top bit set indicates not null

                {

                aOutput << "[Address=";

                const Parser::CContextIdentifier* context = ::gMsgDefParser->FindContextBySize(rtCtx.iSize & 0x7f); // top bit indicates NULL

                if (context)

                    {

                    if (length == context->TotalSize())

                        {

                        context->Describe(payload, length, NULL, aOutput);

                        }

                    else

                        {

                        aOutput << "**** ERROR: ELogAddress - Event data size and context size don't match **** ";

                        }

                    }

                else

                    {

                    aOutput << "**** ERROR: ELogAddress - Logged address uses undefined context type **** ";

                    }

                aOutput << "] ";

                }

            else

                {

                aOutput << "[Address=Null] ";

                }

            }

            break;

        case ELogNode:

            {

            aOutput << "[ANode=0x" << std::hex << std::setw(8)

                << std::setfill('0') << std::nouppercase  << std::noshowbase

                << BytesToInt(payload)

                << "] ";

            }

            break;

        default:

            aOutput << "**** ERROR: Unknown or unsupported log statement **** ";

            break;

        }

    }