/*

* 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 static class SymBitUtils

    {

        #region API

        public static uint CreateMask( string aBinary )

        {

            uint value;

            return CreateMask( aBinary, out value );

        }

        public static uint CreateMask( string aBinary, out uint aExpectedValue )

        {

            uint mask = 0;

            aExpectedValue = 0;

            int bit = 0;

            int count = aBinary.Length;

            for ( int charIndex = count - 1; charIndex >= 0; charIndex-- )

            {

                // Get a character from the string

                char c = Char.ToLower( aBinary[ charIndex ] );

                //

                if ( c == SymBitUtils.KBitIsSet )

                {

                    mask |= (uint) ( 1 << bit );

                    aExpectedValue |= (uint) ( 1 << bit );

                }

                else if ( c == SymBitUtils.KBitIsClear )

                {

                    mask |= (uint) ( 1 << bit );

                }

                else if ( c == SymBitUtils.KBitIsNotApplicable1 || c == SymBitUtils.KBitIsNotApplicable2 )

                {

                }

                //

                if ( c != SymBitUtils.KBitIsReadabilitySpacer )

                {

                    ++bit;

                }

            }

            //

            return mask;

        }

        public static byte CreateMask( string aBinary, out byte aExpectedValue )

        {

            uint value;

            uint ret = CreateMask( aBinary, out value );

            //

            if ( ret > 0xFF || value > 0xFF )

            {

                throw new ArgumentException( "Binary sequence is too large to fit byte" );

            }

            //

            aExpectedValue = (byte) value;

            return (byte) ret;

        }

        public static SymByte CreateMask( string aBinary, out SymByte aExpectedValue )

        {

            byte value = 0;

            SymByte ret = CreateMask( aBinary, out value );

            aExpectedValue = value;

            return ret;

        }

        public static string GetBits( byte aByte )

        {

            string ret = System.Convert.ToString( aByte, 2 ).PadLeft( 8, KBitIsClear );

            return ret;

        }

        public static uint StringToUint( string aText )

        {

            uint ret = 0;

            //

            int bit = 0;

            int count = aText.Length;

            for ( int charIndex = count - 1; charIndex >= 0; charIndex--, ++bit )

            {

                char c = char.ToLower( aText[ charIndex ] );

                //

                if ( c == KBitIsSet )

                {

                    uint mergeIn = (uint) ( 1 << bit );

                    ret |= mergeIn;

                }

            }

            //

            return ret;

        }

        public static string BeautifyBits( uint aAddress, int aNumberOfKnownBits )

        {

            string binAddress = System.Convert.ToString( aAddress, 2 );

            //

            binAddress = binAddress.PadLeft( 32, '0' );

            binAddress = binAddress.Substring( 32 - aNumberOfKnownBits, aNumberOfKnownBits );

            binAddress = binAddress.PadLeft( 32, 'x' );

            binAddress = BeautifyBits( binAddress );

            //

            return binAddress;

        }

        public static string BeautifyBits( string aBits )

        {

            StringBuilder ret = new StringBuilder( aBits.PadLeft( 32, 'x' ) );

            ret.Insert( 24, ' ' );

            ret.Insert( 16, ' ' );

            ret.Insert( 08, ' ' );

            return ret.ToString();

        }

        public static uint RotateRight( uint aValue, int aCount )

        {

            uint ret = aValue;

            //

            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 ret;

        }

        public static SymBit GetBit( uint aValue, int aBitNumber )

        {

            uint mask = 1u << aBitNumber;

            uint value = aValue & mask;

            SymBit ret = ( value != 0 ) ? SymBit.ESet : SymBit.EClear;

            return ret;

        }

        #endregion

        #region Internal constants

        internal const char KBitIsSet = '1';

        internal const char KBitIsClear = '0';

        internal const char KBitIsNotApplicable1 = '#';

        internal const char KBitIsNotApplicable2 = 'x';

        internal const char KBitIsReadabilitySpacer = ' ';

        private const uint KTopBit = 0x80000000;

        #endregion

    }

}