/*
* 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.Generic;
using CrashItemLib.Crash;
using CrashItemLib.Crash.Base;
using CrashItemLib.Crash.Container;
using CrashItemLib.Crash.Registers;
using CrashItemLib.Crash.Registers.Visualization.Bits;

namespace CrashItemLib.Crash.Registers.Visualization.Utilities
{
    public static class VisUtilities
    {
        public static IEnumerable<CIRegisterVisBit> ExtractBits( CIContainer aContainer, uint aValue, string aByte3Mask, string aByte2Mask, string aByte1Mask, string aByte0Mask )
        {
            return ExtractBits( aContainer, aValue, aByte3Mask + aByte2Mask + aByte1Mask + aByte0Mask );
        }

        public static IEnumerable<CIRegisterVisBit> ExtractBits( CIContainer aContainer, uint aValue, string aMask )
        {
            List<CIRegisterVisBit> ret = new List<CIRegisterVisBit>();
            //
            int shift = 0;
            int sigBitCount = 0;
            uint mask = MakeMask( aMask, out shift, out sigBitCount );
            uint maskedValue = ( aValue & mask ) >> shift;

            // Now make bits
            for ( int i = sigBitCount-1; i >= 0; i-- )
            {
                mask = (uint) ( 1u << i );
                uint value = ( maskedValue & mask ) >> i;

                CIRegisterVisBit bit = new CIRegisterVisBit( aContainer );
                if ( value != 0 )
                {
                    bit.Value = TBit.EBitSet;
                }
                ret.Add( bit );
            }

            return ret.ToArray();
        }

        public static TBit ExtractBit( uint aValue, string aByte1Mask, string aByte0Mask )
        {
            string b0 = EnsureByteMask( aByte0Mask );
            string b1 = EnsureByteMask( aByte1Mask );
            //
            int shift;
            uint mask = MakeMask( b1 + b0, out shift );
            //
            uint value = aValue & mask;
            value >>= shift;
            //
            if ( value == 1 )
            {
                return TBit.EBitSet;
            }

            return TBit.EBitClear;
        }

        public static TBit ExtractBit( uint aValue, string aByte3Mask, string aByte2Mask, string aByte1Mask, string aByte0Mask )
        {
            string b0 = EnsureByteMask( aByte0Mask );
            string b1 = EnsureByteMask( aByte1Mask );
            string b2 = EnsureByteMask( aByte2Mask );
            string b3 = EnsureByteMask( aByte3Mask );
            //
            int shift;
            uint mask = MakeMask( b3 + b2 + b1 + b0, out shift );
            //
            uint value = aValue & mask;
            value >>= shift;
            //
            if ( value == 1 )
            {
                return TBit.EBitSet;
            }

            return TBit.EBitClear;
        }

        // [ aByte0 ] 
        public static uint MakeMask( string aByte )
        {
            return MakeMask( string.Empty, string.Empty, string.Empty, aByte );
        }

        // [ aByte1 ] [ aByte0 ] 
        public static uint MakeMask( string aByte1, string aByte0 )
        {
            return MakeMask( string.Empty, string.Empty, aByte1, aByte0 );
        }

        // [ aByte3 ] [ aByte2 ] [ aByte1 ] [ aByte0 ] 
        public static uint MakeMask( string aByte3, string aByte2, string aByte1, string aByte0 )
        {
            int shift = 0;
            return MakeMask( aByte3, aByte2, aByte1, aByte0, out shift );
        }

        public static uint MakeMask( string aByte3, string aByte2, string aByte1, string aByte0, out int aShiftAmount )
        {
            string byteString3 = EnsureByteMask( aByte3 );
            string byteString2 = EnsureByteMask( aByte2 );
            string byteString1 = EnsureByteMask( aByte1 );
            string byteString0 = EnsureByteMask( aByte0 );
            string byteString = byteString3 + byteString2 + byteString1 + byteString0;
            //
            uint mask = MakeMask( byteString, out aShiftAmount );
            //
            return mask;
        }

        public static uint MakeMask( string aSpec, out int aShiftAmount )
        {
            int sigBitCount = 0;
            return MakeMask( aSpec, out aShiftAmount, out sigBitCount );
        }

        public static uint MakeMask( string aSpec, out int aShiftAmount, out int aSignificantBitCount )
        {
            bool setFirstBitIndex = false;
            aShiftAmount = 0;
            aSignificantBitCount = 0;
            uint mask = 0;

            // Loop through all characters in the mask, starting from the RHS, working
            // towards the left hand side.
            int count = aSpec.Length;
            for ( int bit = 0; bit < count; bit++ )
            {
                // Get a character from the string, starting at the RHS
                char c = aSpec[ count - bit - 1 ];
                //
                if ( c == KBitIsSet )
                {
                    mask |= (uint) ( 1u << bit );
                    if ( !setFirstBitIndex )
                    {
                        aShiftAmount = bit;
                        setFirstBitIndex = true;
                    }
                    ++aSignificantBitCount;
                }
                else if ( c == KBitIsClear )
                {
                    if ( !setFirstBitIndex )
                    {
                        aShiftAmount = bit;
                        setFirstBitIndex = true;
                    }
                    ++aSignificantBitCount;
                }
                else if ( c == KBitIsNotApplicable )
                {
                }
            }
            //
            return mask;
        }

        public static string EnsureByteMask( string aMask )
        {
            string ret = aMask.PadLeft( 8, '0' );
            return ret;
        }

        public static string ToBinary( uint aValue )
        {
            StringBuilder ret = new StringBuilder();
            //
            for ( int i = 31; i >= 0; i-- )
            {
                uint mask = (uint) ( 1u << i );
                uint value = ( aValue & mask ) >> i;
                if ( value != 0 )
                {
                    ret.Append( '1' );
                }
                else
                {
                    ret.Append( '0' );
                }
            }
            //
            return ret.ToString();
        }

        #region Constants
        public const char KBitIsSet = '1';
        public const char KBitIsClear = '0';
        public const char KBitIsNotApplicable = '#';
        #endregion
    }
}