using System;
using System.Collections;
using System.Linq;
using System.Text;

namespace LibrarySDR.Helpers
{
    public class BinaryHexHelper
    {
        /// <summary>
        /// Define ways of adding paddings to a hex string 
        /// </summary>
        public enum Padding { LEFT, RIGHT };

        public enum Endian { LITTLE, BIG };

        public static Endian EndianType = Endian.LITTLE;

        /// <summary>
        /// Method that will convert a binary string to the corresponding hex string 
        /// by adding additional 0's in front of the binary number until a multiple of 8 is obtained 
        /// </summary>
        /// <param name="binary">A binary number as a string</param>
        /// <returns>String representing the hex value of the binary string</returns>
        public static string BinaryStringToHexString(string binary)
        {
            return _BinaryStringToHexString(binary, Padding.LEFT);
        }


        /// <summary>
        /// Method that will convert a binary string to the corresponding hex string 
        /// by adding additional 0's until a multiple of 8 is obtained 
        /// </summary>
        /// <param name="binary">A binary number as a string</param>
        /// <param name="padding">Padding option to which the additional 0's are added</param>
        /// <returns>String representing the hex value of the binary string</returns>
        public static string BinaryStringToHexString(string binary, Padding padding)
        {
            return _BinaryStringToHexString(binary, padding);
        }


        /// <summary>
        /// Private method that will convert a binary string to the corresponding hex string 
        /// by adding additional 0's until a multiple of 8 is obtained 
        /// </summary>
        /// <param name="binary">A binary number as a string</param>
        /// <param name="padding">Padding option to which the additional 0's are added</param>
        /// <returns>String representing the hex value of the binary string</returns>
        private static string _BinaryStringToHexString(string binary, Padding padding)
        {
            StringBuilder result = new StringBuilder(binary.Length / 8 + 1);

            // TODO: check all 1's or 0's... Will throw otherwise

            int mod4Len = binary.Length % 8;
            if (mod4Len != 0)
            {
                // pad to length multiple of 8 if required
                if (padding == Padding.RIGHT)
                    binary = binary.PadRight(((binary.Length / 8) + 1) * 8, '0');
                else if (padding == Padding.LEFT)
                    binary = binary.PadLeft(((binary.Length / 8) + 1) * 8, '0');
            }


            for (int i = 0; i < binary.Length; i += 8)
            {
                string eightBits = binary.Substring(i, 8);
                result.AppendFormat("{0:X2}", Convert.ToByte(eightBits, 2));
            }

            return result.ToString().Trim();
        }

        public static String GetBits(string str, Encoding encoding)
        {
            byte[] data = encoding.GetBytes(str);

            //storage for the resulting string
            string result = string.Empty;
            //iterate through the byte[]
            foreach (byte value in data)
            {
                //storage for the individual byte
                string binarybyte = Convert.ToString(value, 2);
                //if the binarybyte is not 8 characters long, its not a proper result
                while (binarybyte.Length < 8)
                {
                    //prepend the value with a 0
                    binarybyte = "0" + binarybyte;
                }
                //append the binarybyte to the result
                result += binarybyte;
            }
            //return the result
            return result;
        }



        public static String LittleToBigEndianHexString(String littleEndianHexString)
        {

            StringBuilder sb = new StringBuilder("");

            for (int i = 0; i < littleEndianHexString.Length / 2; i++)
                sb.Append(littleEndianHexString.Substring((littleEndianHexString.Length / 2 - i - 1) * 2, 2));

            return sb.ToString();
        }




        /// <summary>
        /// Get corresponding bits as a string for the desired int value. The number of bits is specified 
        /// </summary>
        /// <param name="value">Int value that needs to be transformed to binary string</param>
        /// <param name="bitLength">Numer of bits that needs to be returned (the added ones will be 0)</param>
        /// <returns>String represents the bits of an int value</returns>
        public static String GetBits(Int64 value, int bitLength)
        {
            return _GetBits(value, bitLength, true);
        }

        /// <summary>
        /// Get corresponding bits as a string for the desired int value. The number of bits is specified 
        /// </summary>
        /// <param name="value">Int value that needs to be transformed to binary string</param>
        /// <param name="bitLength">Numer of bits that needs to be returned</param>
        /// <param name="isZeroPadded">Specify if the added bits should be 0 or 1</param>
        /// <returns>String represents the bits of an int value</returns>
        public static String GetBits(Int64 value, int bitLength, bool isZeroPadded)
        {
            return _GetBits(value, bitLength, isZeroPadded);
        }

        /// <summary>
        /// Get corresponding bits as a string for the desired int value. The number of bits is specified 
        /// </summary>
        /// <param name="value">Int value that needs to be transformed to binary string</param>
        /// <param name="bitLength">Numer of bits that needs to be returned</param>
        /// <param name="isZeroPadded">Specify if the added bits should be 0 or 1</param>
        /// <returns>String represents the bits of an int value</returns>
        private static string _GetBits(Int64 value, int bitLength, bool isZeroPadded)
        {
            String result = Convert.ToString(value, 2).PadLeft(bitLength, isZeroPadded ? '0' : '1');

            // revers bytes if little endian
            if(EndianType == Endian.LITTLE)
            {
                StringBuilder sb = new StringBuilder("");

                for (int i = 0; i < result.Length / 8; i++)
                    sb.Append(result.Substring((result.Length / 8 - i - 1) * 8, 8));

                result = sb.ToString();
            }

            /*
            
            byte[] arrayResponse = BitConverter.GetBytes(value);
            
            // if system is in BigEndian and the required is for little
            if ((!BitConverter.IsLittleEndian && EndianType == Endian.LITTLE)
                || (BitConverter.IsLittleEndian && EndianType == Endian.BIG))
                Array.Reverse(arrayResponse);
     
            return BitConverter.ToString(arrayResponse);
            */
            return result;
        }



        public static byte[] StringToByteArray(string hex)
        {
            return Enumerable.Range(0, hex.Length)
                             .Where(x => x % 2 == 0)
                             .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                             .ToArray();
        }


        public static byte[] StringToByteArrayFastest(string hex)
        {
            if (hex.Length % 2 == 1)
                throw new Exception("The binary key cannot have an odd number of digits");

            byte[] arr = new byte[hex.Length >> 1];

            for (int i = 0; i < hex.Length >> 1; ++i)
            {
                arr[i] = (byte)((GetHexVal(hex[i << 1]) << 4) + (GetHexVal(hex[(i << 1) + 1])));
            }

            return arr;
        }

        private static int GetHexVal(char hex)
        {
            int val = (int)hex;
            //For uppercase A-F letters:
            return val - (val < 58 ? 48 : 55);
            //For lowercase a-f letters:
            //return val - (val < 58 ? 48 : 87);
            //Or the two combined, but a bit slower:
            //return val - (val < 58 ? 48 : (val < 97 ? 55 : 87));
        }



        public static string GetEscapeSequence(char c)
        {
            //return "\\u" + 
            return ((int)c).ToString("X4");
        }



        public static string ToBitString(BitArray bits, Endian endian)
        {
            if (endian == Endian.LITTLE)
            {
                var sb = new StringBuilder();

                for (int i = 0; i < bits.Count; i++)
                {
                    char c = bits[i] ? '1' : '0';
                    sb.Append(c);
                }

                return sb.ToString();
            }
            else
            {
                var sb = new StringBuilder();


                for (int i = bits.Count / 2 - 1; i >= 0; i--)
                {
                    char c = bits[i] ? '1' : '0';
                    sb.Append(c);
                }


                for (int i = bits.Count - 1; i >= bits.Count /2; i--)
                {
                    char c = bits[i] ? '1' : '0';
                    sb.Append(c);
                }

                return sb.ToString();
            }
        }
    }
}