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

namespace SymbianUtils.RawItems
{
	public class RawItem
	{
		#region Constructors
        public RawItem()
            : this( 0, 0, 0, "...." )
        {
        }

        public RawItem( uint aAddress, uint aReversedData, uint aOriginalData, string aCharacterisedData )
		{
			iAddress = aAddress;
			iData = aReversedData;
			iOriginalData = aOriginalData;
			iCharacterisedData = aCharacterisedData;
		}

        public RawItem( uint aAddress, uint aData )
        {
            iAddress = aAddress;
            iData = aData;
            
            // Reverse bytes to get the original data
            uint[] bytes = AsBytes( aData );
			iOriginalData = SwapEndianness( bytes );

            // Get chars
            iCharacterisedData = ConvertToCharacters( bytes );
        }
		#endregion

        #region API
        public int PrintableCharacterCount( bool aUnicode, ref int aDotCount )
        {
            int count = 0;
            //
            int start = ( aUnicode ) ? 1 : 0;
            int delta = ( aUnicode ) ? 2 : 1;
            int length = iCharacterisedData.Length;
            //
            for ( int i = start; i < length; i += delta )
            {
                char c = iCharacterisedData[ i ];
                int charAsInt = System.Convert.ToInt32( c );

                if ( c >= 32 && c < 128 || c == 0x0D || c == 0x0A || c == 0x09 )
                {
                    ++count;
                }
                if ( c == '.' )
                {
                    ++aDotCount;
                }
            }
            return count;
        }
        #endregion

        #region Properties
        public uint Address
		{
			get { return iAddress; }
			set { iAddress = value; }
		}

		public uint Data
		{
			get { return iData; }
			set { iData = value; }
		}

        public byte[] DataArray
        {
            get
            {
                byte[] ret = new byte[ 4 ];
                //
                ret[ 0 ] = (byte) ( ( iData >> 0 ) & 0xFF );
                ret[ 1 ] = (byte) ( ( iData >> 8 ) & 0xFF );
                ret[ 2 ] = (byte) ( ( iData >> 16 ) & 0xFF );
                ret[ 3 ] = (byte) ( ( iData >> 24 ) & 0xFF );
                //
                return ret;
            }
        }

        public ushort[] DataArrayWords
        {
            get
            {
                ushort[] ret = new ushort[ 2 ];
                //
                ret[ 0 ] = (ushort) ( ( iData )       & 0x0000FFFF );
                ret[ 1 ] = (ushort) ( ( iData >> 16 ) & 0x0000FFFF );
                //
                return ret;
            }
        }

		public uint OriginalData
		{
			get { return iOriginalData; }
			set { iOriginalData = value; }
		}

		public string CharacterisedData
		{
			get { return iCharacterisedData; }
			set { iCharacterisedData = value; }
		}

		public string OriginalCharacterisedData
		{
			get 
			{
				char[] reversedCharacterisedData = new char[ iCharacterisedData.Length ];
				for (int i = 0; i < iCharacterisedData.Length; i+=4)
				{
					string bytes = iCharacterisedData.Substring(i, 4);
					reversedCharacterisedData[i]   = bytes[3];
					reversedCharacterisedData[i+1] = bytes[2];
					reversedCharacterisedData[i+2] = bytes[1];
					reversedCharacterisedData[i+3] = bytes[0];
				}
				//
				string characterisedData = new string(reversedCharacterisedData);
				return characterisedData;
			}
		}

		public string OriginalCharacterisedDataAsUnicode
		{
			get 
			{
                StringBuilder text = new StringBuilder( OriginalCharacterisedData );
				for( int i = text.Length-1; i >= 0; i-=2 )
				{
                    text.Remove( i, 1 );
				}
                string ret = text.ToString();
                return ret;
			}
		}

        public object Tag
		{
			get { return iTag; }
			set { iTag = value; }
		}

        public static uint RoundToNearestDWord( uint aValue )
        {
            uint dwords = aValue / KSizeOfOneRawItemInBytes;
            uint ret = dwords * KSizeOfOneRawItemInBytes;
            uint remainder = aValue % KSizeOfOneRawItemInBytes;
            //
            if ( remainder > 0 )
            {
                ret += KSizeOfOneRawItemInBytes;
            }
            //
            return ret;
        }
		#endregion

        #region Constants
        public const uint KSizeOfOneRawItemInBytes = 4;
        #endregion

        #region Internal methods
        private static uint[] AsBytes( uint aValue )
        {
            uint[] ret = new uint[4];
            //
            ret[ 0 ] = ( aValue ) & 0xFF;
            ret[ 1 ] = ( aValue >> 8 ) & 0xFF;
            ret[ 2 ] = ( aValue >> 16 ) & 0xFF;
            ret[ 3 ] = ( aValue >> 24 ) & 0xFF;
            //
            return ret;
        }

        private static uint SwapEndianness( uint aValue )
        {
            uint[] bytes = AsBytes( aValue );
            return SwapEndianness( bytes );
        }

        private static uint SwapEndianness( uint[] aBytes )
        {
            System.Diagnostics.Debug.Assert( aBytes.Length == KSizeOfOneRawItemInBytes );
            uint ret = 0;
            //
            ret += ( aBytes[ 3 ] <<  0 );
            ret += ( aBytes[ 2 ] <<  8 );
            ret += ( aBytes[ 1 ] << 16 );
            ret += ( aBytes[ 0 ] << 24 );
            //
            return ret;
        }

        private static string ConvertToCharacters( uint[] aBytes )
        {
            StringBuilder ret = new StringBuilder();
            //
            foreach ( uint val in aBytes )
            {
                char c = System.Convert.ToChar( val );
                //
    			if ( c <= 0x20 || c >= 0x7f || c == '%' )
                {
                    c = '.';
                }
                //
                ret.Insert( 0, c );
            }
            //
            return ret.ToString();
        }
        #endregion

        #region Data members
        private object iTag = null;
		private uint iAddress;
		private uint iData;
		private uint iOriginalData;
		private string iCharacterisedData = string.Empty;
		#endregion
	}
}