/*

* 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.Text;

using System.Collections;

using System.Collections.Generic;

namespace SymbianUtils.Utilities

{

	public class RawByteUtility

	{

		public static void ConvertToCharacter( byte aByte, StringBuilder aBuilder )

		{

			if	( aByte <= 32 || aByte > 126 )

			{

				aBuilder.Append( '.' );

			}

			else

			{

				aBuilder.Append( System.Convert.ToChar( aByte ) );

			}

		}

        public static string ConvertDataToText( IEnumerable<byte> aBytes, bool aFlushEntireList, ref uint aStartingAddress )

        {

            Queue<byte> queue = new Queue<byte>();

            foreach ( byte b in aBytes )

            {

                queue.Enqueue( b );

            }

            return ConvertDataToText( queue, aFlushEntireList, ref aStartingAddress );

        }

        public static string ConvertDataToText( Queue<byte> aByteQueue, bool aFlushEntireQueue, ref uint aStartingAddress )

        {

            RawByteConverter converter = new RawByteConverter();

            string ret = converter.Convert( aByteQueue, aFlushEntireQueue, ref aStartingAddress );

            return ret;

        }

		public static uint CombineBytes( uint aByte0, uint aByte1, uint aByte2, uint aByte3 )

		{

			aByte0 = ( aByte0 << 24 );

			aByte1 = ( aByte1 << 16 );

			aByte2 = ( aByte2 <<  8 );

			//

			uint ret = ( aByte0 + aByte1 + aByte2 + aByte3 );

			//

			return ret;

		}

        public static string CreateHexData( byte aByte0, byte aByte1, byte aByte2, byte aByte3 )

		{

			StringBuilder charData = new StringBuilder();

			//

			charData.Append( aByte0.ToString("x2") + " " );

			charData.Append( aByte1.ToString("x2") + " " );

			charData.Append( aByte2.ToString("x2") + " " );

			charData.Append( aByte3.ToString("x2") + " " );

			//

			string charDataString = charData.ToString();

			return charDataString;

		}

        public static string CreateCharacterisedData( uint aDWord )

        {

            byte b3 = (byte) (   aDWord & 0x000000FF );

            byte b2 = (byte) ( ( aDWord & 0x0000FF00 ) >>  8 );

            byte b1 = (byte) ( ( aDWord & 0x00FF0000 ) >> 16 );

            byte b0 = (byte) ( ( aDWord & 0xFF000000 ) >> 24 );

            //

            return CreateCharacterisedData( b0, b1, b2, b3 );

        }

        public static string CreateCharacterisedData( byte[] aBytes )

        {

            if ( aBytes.Length != 4 )

            {

                throw new ArgumentException( "Expected 4 byte array" );

            }

            return CreateCharacterisedData( aBytes[ 0 ], aBytes[ 1 ], aBytes[ 2 ], aBytes[ 3 ] );

        }

		public static string CreateCharacterisedData( byte aByte0, byte aByte1, byte aByte2, byte aByte3 )

		{

			StringBuilder charData = new StringBuilder();

			//

			ConvertToCharacter( aByte3, charData );

			ConvertToCharacter( aByte2, charData );

			ConvertToCharacter( aByte1, charData );

			ConvertToCharacter( aByte0, charData );

			//

			string charDataString = charData.ToString();

			return charDataString;

		}

	}

    public class RawByteConverter

    {

        #region Delegates & events

        public delegate void HandleLine( string aLine );

        public event HandleLine iLineHandler;

        #endregion

        #region Constructors

        public RawByteConverter()

        {

        }

        #endregion

        #region API

        public string Convert( Queue<byte> aByteQueue, bool aFlushEntireQueue, ref uint aStartingAddress )

        {

            const int KNumberOfBytesPerLine = 16;

            StringBuilder ret = new StringBuilder();

            // First try to build entire lines of 16 bytes

            while ( aByteQueue.Count >= KNumberOfBytesPerLine )

            {

                StringBuilder byteVals = new StringBuilder();

                byteVals.Append( aStartingAddress.ToString( "x8" ) + ": " );

                int bytesProcessedForThisLine = 0;

                //

                StringBuilder byteChars = new StringBuilder();

                while ( bytesProcessedForThisLine != KNumberOfBytesPerLine )

                {

                    // Extract at most 4 bytes of data to process

                    byte b0 = aByteQueue.Dequeue();

                    byte b1 = aByteQueue.Dequeue();

                    byte b2 = aByteQueue.Dequeue();

                    byte b3 = aByteQueue.Dequeue();

                    // Create double-char hex representation of each character

                    byteVals.Append( RawByteUtility.CreateHexData( b0, b1, b2, b3 ) );

                    // Character representation of data...

                    byteChars.Append( RawByteUtility.CreateCharacterisedData( b0, b1, b2, b3 ) );

                    // Handle new line scenario

                    bytesProcessedForThisLine += 4;

                }

                byteVals.Append( byteChars.ToString() );

                byteVals.Append( System.Environment.NewLine );

                //

                if ( iLineHandler != null )

                {

                    iLineHandler( byteVals.ToString() );

                }

                //

                ret.Append( byteVals.ToString() );

                aStartingAddress += KNumberOfBytesPerLine;

            }

            // Extract remaining data only if the client specified that the entire queue should

            // be emptied

            int numberLeft = aByteQueue.Count;

            if ( aFlushEntireQueue && numberLeft > 0 && numberLeft < 16 )

            {

                StringBuilder byteVals = new StringBuilder();

                byteVals.Append( aStartingAddress.ToString( "x8" ) + ": " );

                //

                StringBuilder byteChars = new StringBuilder();

                while ( aByteQueue.Count > 0 )

                {

                    byte b0 = aByteQueue.Dequeue();

                    // Create double-char hex representation of each character

                    byteVals.Append( b0.ToString( "x2" ) + " " );

                    // Character representation of data...

                    RawByteUtility.ConvertToCharacter( b0, byteChars );

                }

                // We may need to pad some bytes

                int padCount = KNumberOfBytesPerLine - numberLeft;

                while ( padCount > 0 )

                {

                    byteVals.Append( "  " + " " );

                    byteChars.Append( "." );

                    --padCount;

                }

                // Combine data

                byteVals.Append( byteChars.ToString() );

                byteVals.Append( System.Environment.NewLine );

                //

                if ( iLineHandler != null )

                {

                    iLineHandler( byteVals.ToString() );

                }

                //

                ret.Append( byteVals.ToString() );

                aStartingAddress += (uint) numberLeft;

            }

            return ret.ToString();

        }

        #endregion

        #region Data members

        #endregion

    }

}