/*

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

namespace SymbianUtils.BasicTypes

{

    public class SymUInt32 : SymUIntBase

    {

        #region Constructors

        public SymUInt32( uint aValue )

            : base( aValue, 32 )

        {

        }

        public SymUInt32( string aBinary )

            : base( aBinary, 32 )

        {

        }

        #endregion

        #region Operators

        public static SymUInt32 operator &( SymUInt32 aLeft, SymUInt32 aRight )

        {

            uint val = aLeft.RawValue & aRight.RawValue;

            return new SymUInt32( val );

        }

        public static implicit operator SymUInt32( uint aBasicType )

        {

            return new SymUInt32( aBasicType );

        }

        #endregion

    }

    public class SymUInt16 : SymUIntBase

    {

        #region Constructors

        public SymUInt16( ushort aValue )

            : base( aValue, 16 )

        {

        }

        public SymUInt16( string aBinary )

            : base( aBinary, 16 )

        {

        }

        #endregion

        #region Operators

        public static SymUInt16 operator &( SymUInt16 aLeft, SymUInt16 aRight )

        {

            ushort val = Convert.ToUInt16( aLeft.RawValue & aRight.RawValue );

            return new SymUInt16( val );

        }

        public static implicit operator SymUInt16( ushort aBasicType )

        {

            return new SymUInt16( aBasicType );

        }

        #endregion

    }

    public class SymUInt8 : SymUIntBase

    {

        #region Constructors

        public SymUInt8( byte aValue )

            : base( aValue, 8 )

        {

        }

        public SymUInt8( string aBinary )

            : base( aBinary, 8 )

        {

        }

        #endregion

        #region Operators

        public static SymUInt8 operator &( SymUInt8 aLeft, SymUInt8 aRight )

        {

            byte val = Convert.ToByte( aLeft.RawValue & aRight.RawValue );

            return new SymUInt8( val );

        }

        public static implicit operator SymUInt8( byte aBasicType )

        {

            return new SymUInt8( aBasicType );

        }

        #endregion

    }

    public abstract class SymUIntBase : IFormattable

    {

        #region Constructors

        protected SymUIntBase()

        {

        }

        protected SymUIntBase( string aBinary, int aNumberOfBits )

        {

            iValue = SymBitUtils.CreateMask( aBinary );

            iNumberOfBits = aNumberOfBits;

        }

        protected SymUIntBase( uint aValue, int aNumberOfBits )

        {

            iValue = aValue;

            iNumberOfBits = aNumberOfBits;

        }

        #endregion

        #region API

        public bool IsMatch( string aBinary )

        {

            uint value = 0;

            uint mask = SymBitUtils.CreateMask( aBinary, out value );

            bool ret = ( mask & iValue ) == value;

            return ret;

        }

        public uint RShift( int aBits )

        {

            uint v = iValue;

            v >>= aBits;

            this.RawValue = v;

            return v;

        }

        public uint LShift( int aBits )

        {

            uint v = (uint) ( iValue << aBits );

            this.RawValue = v;

            return v;

        }

        public SymUInt32 RotateRight( int aCount )

        {

            uint ret = iValue;

            //

            for ( int i = 0; i < aCount; i++ )

            {

                bool bitZeroSet = ( ( ret & 0x1 ) == 0x1 );

                ret >>= 1;

                //

                if ( bitZeroSet )

                {

                    // Wrap the bit around by appling it at the top end

                    ret |= KTopBit;

                }

            }

            //

            return new SymUInt32( ret );

        }

        public uint ToUInt()

        {

            return iValue;

        }

        #endregion

        #region Properties

        public int NumberOfBits

        {

            get { return iNumberOfBits; }

            protected set

            {

                switch ( value )

                {

                default:

                    throw new ArgumentException( "Number of bits must be 8, 16 or 32" );

                case 8:

                case 16:

                case 32:

                    iNumberOfBits = value;

                    break;

                }

            }

        }

        public int NumberOfBytes

        {

            get { return NumberOfBits / 4; }

            set

            {

                this.NumberOfBits = value * 8;

            }

        }

        public uint MaxValue

        {

            get

            {

                uint ret = uint.MaxValue;

                if ( iNumberOfBits == 16 )

                {

                    ret = ushort.MaxValue;

                }

                else if ( iNumberOfBits == 8 )

                {

                    ret = byte.MaxValue;

                }

                return ret;

            }

        }

        public string Binary

        {

            get

            {

                string bits = SymBitUtils.BeautifyBits( iValue, iNumberOfBits );

                return bits;

            }

        }

        public string Hex

        {

            get

            {

                string hex = iValue.ToString( string.Format( "x{0}", this.NumberOfBytes * 2 ) );

                return hex;

            }

        }

        public SymBit this[ int aIndex ]

        {

            get

            {

                if ( aIndex < 0 || aIndex > iNumberOfBits )

                {

                    throw new ArgumentException( "Specified bit is out of bounds" );

                }

                uint mask = ( 1u << aIndex );

                SymBit ret = ( ( mask & iValue ) == mask ) ? SymBit.ESet : SymBit.EClear;

                return ret;

            }

        }

        public SymUInt32 this[ int aHighBitIndex, int aLowBitIndex ]

        {

            get

            {

                if ( aHighBitIndex < aLowBitIndex )

                {

                    throw new ArgumentException( "High bit index must be less than low bit index" );

                }

                // Build mask

                uint mask = 0;

                for ( int i = aLowBitIndex; i <= aHighBitIndex; i++ )

                {

                    mask |= ( 1u << i );

                }

                uint ret = iValue & mask;

                // Shift

                ret >>= aLowBitIndex;

                return new SymUInt32( ret );

            }

        }

        #endregion

        #region Operators

        public static implicit operator uint( SymUIntBase aObject )

        {

            return aObject.RawValue;

        }

        public static implicit operator ushort( SymUIntBase aObject )

        {

            ushort ret = Convert.ToUInt16( aObject.RawValue );

            return ret;

        }

        public static implicit operator byte( SymUIntBase aObject )

        {

            byte ret = Convert.ToByte( aObject.RawValue );

            return ret;

        }

        public static bool operator ==( SymUIntBase aLeft, SymUIntBase aRight )

        {

            // If both are null, or both are same instance, return true.

            if ( System.Object.ReferenceEquals( aLeft, aRight ) )

            {

                return true;

            }

            // If one is null, but not both, return false.

            if ( ( (object) aLeft == null ) || ( (object) aRight == null ) )

            {

                return false;

            }

            bool ret = aLeft.Equals( aRight );

            return ret;

        }

        public static bool operator !=( SymUIntBase aLeft, SymUIntBase aRight )

        {

            bool result = !( aLeft == aRight );

            return result;

        }

        public static SymUInt32 operator &( SymUIntBase aLeft, SymUIntBase aRight )

        {

            uint val = ( aLeft.RawValue & aRight.RawValue );

            return new SymUInt32( val );

        }

        #endregion

        #region IFormattable Members

        public string ToString( string aFormat, IFormatProvider aFormatProvider )

        {

            if ( aFormatProvider != null )

            {

                ICustomFormatter formatter = aFormatProvider.GetFormat( this.GetType() ) as ICustomFormatter;

                if ( formatter != null )

                {

                    return formatter.Format( aFormat, this, aFormatProvider );

                }

            }

            string ret = string.Empty;

            string format = aFormat != null ? aFormat : "full";

            //

            switch ( format )

            {

            case "full":

                ret = string.Format( "0x{0} [{1}]", Hex, Binary );

                break;

            default:

                ret = iValue.ToString( aFormat, aFormatProvider );

                break;

            }

            //

            return ret;

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return ToString( null );

        }

        public string ToString( string aFormat )

        {

            return ToString( aFormat, null );

        }

        public override bool Equals( object aObject )

        {

            bool ret = false;

            //

            if ( aObject != null && aObject is SymUIntBase )

            {

                SymUIntBase other = (SymUIntBase) aObject;

                //

                if ( other.NumberOfBits == this.NumberOfBits )

                {

                    ret = ( other.RawValue == this.RawValue );

                }

            }

            //

            return ret;

        }

        public override int GetHashCode()

        {

            return iValue.GetHashCode();

        }

        #endregion

        #region Internal properties & methods

        protected uint RawValue

        {

            get { return iValue; }

            set

            {

                if ( value > MaxValue )

                {

                    throw new ArgumentException( string.Format( "Specified value {0} exceeds bit range ({1})", value, this.NumberOfBits ) );

                }

                iValue = value;

            }

        }

        #endregion

        #region Internal constants

        private const uint KTopBit = 0x80000000;

        #endregion

        #region Data ember

        private uint iValue = 0;

        private int iNumberOfBits = 32;

        #endregion

    }

}