/*

* 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:

*

*/

using System;

using System.Collections.Generic;

using System.IO;

using System.Text;

using SymbianUtils;

using SymbianUtils.Threading;

namespace SymbianStructuresLib.Debug.Trace

{

    public class TraceLine : IFormattable

    {

        #region Enumerations

        public enum TType

        {

            /// <summary>

            /// Plain text trace data

            /// </summary>

            ETypeText = 0,

            /// <summary>

            /// Binary trace data that has been decoded back to text

            /// </summary>

            ETypeBinary,

            /// <summary>

            /// Raw trace data is (usually) binary data that could not be decoded

            /// </summary>

            ETypeRaw

        }

        #endregion

        #region Factory

        public static TraceLine NewText( TraceTimeStamp aTimeStamp, string aPayload )

        {

            TraceLine ret = new TraceLine( aTimeStamp, aPayload, TType.ETypeText );

            return ret;

        }

        public static TraceLine NewRaw( TraceTimeStamp aTimeStamp, byte[] aRawData )

        {

            TraceLine ret = new TraceLine( aTimeStamp, aRawData );

            return ret;

        }

        public static TraceLine NewBinary( TraceTimeStamp aTimeStamp, string aPayload )

        {

            TraceLine ret = new TraceLine( aTimeStamp, aPayload, TType.ETypeBinary );

            return ret;

        }

        #endregion

        #region Constructors

        static TraceLine()

        {

            TraceIdentifier temp = new TraceIdentifier( 0, 0, 0 );

            iTraceIdentifierWidthInCharacters = temp.ToString().Length;

        }

        private TraceLine( TraceTimeStamp aTimeStamp, string aPayload, TType aType )

        {

            iTimeStamp = aTimeStamp;

            iPayload = aPayload;

            iType = aType;

        }

        private TraceLine( TraceTimeStamp aTimeStamp, byte[] aRawData )

            : this( aTimeStamp, string.Empty, TType.ETypeRaw )

        {

            StringBuilder payload = new StringBuilder();

            //

            foreach ( byte b in aRawData )

            {

                payload.AppendFormat( "{0:x2} ", b );

            }

            //

            iPayload = payload.ToString();

        }

        #endregion

        #region API

        public void AddPrefix( int aOrder, string aValue )

        {

            if ( string.IsNullOrEmpty( aValue ) == false )

            {

                TXffix item = new TXffix( aOrder, aValue );

                InsertInSortedOrder( ref iPrefixes, item );

            }

        }

        public void AddSuffix( int aOrder, string aValue )

        {

            if ( string.IsNullOrEmpty( aValue ) == false )

            {

                TXffix item = new TXffix( aOrder, aValue );

                InsertInSortedOrder( ref iSuffixes, item );

            }

        }

        #endregion

        #region Properties

        public TType Type

        {

            get { return iType; }

        }

        public string Prefix

        {

            get

            {

                string ret = XffixListToString( iPrefixes );

                return ret;

            }

        }

        public string Suffix

        {

            get

            {

                string ret = XffixListToString( iSuffixes );

                return ret;

            }

        }

        public string Payload

        {

            get { return iPayload; }

        }

        public uint ContextId

        {

            get { return iContextId; }

            set { iContextId = value; }

        }

        public bool HasIdentifier

        {

            get { return iIdentifier != null; }

        }

        public TraceTimeStamp TimeStamp

        {

            get { return iTimeStamp; }

        }

        public TraceIdentifier Identifier

        {

            get { return iIdentifier; }

            set { iIdentifier = value; }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            // First comes time stamp

            ret.Append( iTimeStamp.ToString() + " " );

            // Prefix with type

            switch ( iType )

            {

            case TType.ETypeBinary:

                ret.Append( "[BIN]" );

                break;

            case TType.ETypeRaw:

                ret.Append( "[RAW]" );

                break;

            case TType.ETypeText:

                ret.Append( "[ASC]" );

                break;

            default:

                ret.Append( "[???]" );

                break;

            }

            ret.Append( " " );

            // Context Id (if available)

            if ( iContextId != 0 )

            {

                ret.AppendFormat( "THD: [{0:x8}]", iContextId );

            }

            else

            {

                ret.Append( "              " );

            }

            ret.Append( " " );

            // Add identifier if present

            if ( iIdentifier != null )

            {

                ret.Append( "ID: " + iIdentifier.ToString() );

            }

            else

            {

                ret.Append( "     " );

                ret.Append( "".PadRight( iTraceIdentifierWidthInCharacters, ' ' ) );

            }

            // Text aspect

            ret.Append( this.GetText() );

            // Done

            return ret.ToString();

        }

        #endregion

        #region From IFormattable

        public string ToString( string aFormat, IFormatProvider formatProvider )

        {

            string ret = string.Empty;

            //

            if ( aFormat.ToUpper() == "TEXT" )

            {

                ret = this.GetText();

            }

            else

            {

                ret = this.ToString();

            }

            //

            return ret;

        }

        #endregion

        #region Internal constants

        #endregion

        #region Internal class

        private class TXffix : IComparer<TXffix>

        {

            #region Constructors

            public TXffix( int aOrder, string aValue )

            {

                iOrder = aOrder;

                iValue = aValue;

            }

            #endregion

            #region From System.Object

            public override string ToString()

            {

                return iValue;

            }

            #endregion

            #region From IComparer<TXffix>

            public int Compare( TXffix aLeft, TXffix aRight )

            {

                int ret = aLeft.iOrder.CompareTo( aRight.iOrder );

                return ret;

            }

            #endregion

            #region Data members

            private readonly int iOrder;

            private readonly string iValue;

            #endregion

        }

        #endregion

        #region Internal methods

        private void InsertInSortedOrder( ref List<TXffix> aList, TXffix aValue )

        {

            if ( aList == null )

            {

                aList = new List<TXffix>();

                aList.Add( aValue );

            }

            else

            {

                int pos = aList.BinarySearch( aValue, aValue as IComparer<TXffix> );

                if ( pos < 0 )

                {

                    pos = ~pos;

                }

                aList.Insert( pos, aValue );

            }

        }

        private string XffixListToString( List<TXffix> aList )

        {

            string ret = string.Empty;

            //

            if ( aList != null )

            {

                StringBuilder sb = new StringBuilder();

                //

                foreach ( TXffix item in aList )

                {

                    sb.Append( item );

                    sb.Append( " " );

                }

                //

                ret = sb.ToString();

            }

            //

            return ret;

        }

        private string GetText()

        {

            StringBuilder ret = new StringBuilder();

            // Now prefix, payload, suffix

            string prefix = XffixListToString( iPrefixes );

            string suffix = XffixListToString( iSuffixes );

            ret.AppendFormat( "    {0}{1}{2}", prefix, iPayload, suffix );

            return ret.ToString();

        }

        #endregion

        #region Data members

        private static int iTraceIdentifierWidthInCharacters;

        private readonly TraceTimeStamp iTimeStamp;

        private readonly string iPayload;

        private readonly TType iType;

        private uint iContextId = 0;

        private List<TXffix> iPrefixes = null;

        private List<TXffix> iSuffixes = null;

        private TraceIdentifier iIdentifier = null;

        #endregion

    }

}