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

namespace DarkBinaryLibrary
{
    public class BinaryType
    {
        private List<bool> content;

        private void add_bits(bool[] bits)
        {
            if (content == null) return;

            foreach (bool i in bits)
            {
                content.Add(i);
            }
        }

        private bool[] byte_to_bits(byte b)
        {
            List<bool> res = new List<bool>();
            bool t;

            for (int i = 1; i < byte.MaxValue; i *= 2)
            {
                t = (b & i) == i;
                res.Add(t);
            }

            res.Reverse();

            return res.ToArray();
        }

        private byte bits_to_byte(bool[] bits)
        {
            if (bits.Length < 8)
                throw new Exception("В массиве недостаточно битов для создания байта");

            byte res = 0;
            byte writer = 1;

            for (int i = 7; i >= 0; i--)
            {
                if (bits[i]) res = (byte)(res | writer);
                writer *= 2;
            }

            return res;
        }

        private byte bits_to_byte(int index)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + 7 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            byte res = 0;
            byte writer = 1;

            for (int i = 7; i >= 0; i--)
            {
                if (content[index + i]) res = (byte)(res | writer);
                writer *= 2;
            }

            return res;
        }

        private int bits_to_int(int index)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + 31 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            int res = 0;
            int writer = 1;

            for (int i = 31; i >= 0; i--)
            {
                if (content[index + i]) res = (res | writer);
                writer *= 2;
            }

            return res;
        }

        private bool[] int_to_bits_with_bit_count(int n, byte bit_count)
        {
            if (bit_count < 1)
                throw new Exception("Слишком маленькое количество бит.");
            if (bit_count > 32)
                throw new Exception("Слишком большое количество бит.");

            int max = 1;
            for (byte i = 1; i <= bit_count; i++)
            {
                max *= 2;
            }

            if (n >= max)
                throw new Exception("Входное число больше максимального допустимого для этого количества бит.");

            List<bool> res = new List<bool>();
            int reader = 1;

            for (byte i = 0; i < bit_count; i++)
            {
                res.Add((n & reader) == reader);
                reader *= 2;
            }

            res.Reverse();

            return res.ToArray();
        }

        private bool[] byte_to_bits_with_bit_count(byte n, byte bit_count)
        {
            if (bit_count < 1)
                throw new Exception("Слишком маленькое количество бит.");
            if (bit_count > 8)
                throw new Exception("Слишком большое количество бит.");

            int max = 1;
            for (byte i = 1; i <= bit_count; i++)
            {
                max *= 2;
            }

            if (n >= max)
                throw new Exception("Входное число больше максимального допустимого для этого количества бит.");

            List<bool> res = new List<bool>();
            byte reader = 1;

            for (byte i = 0; i < bit_count; i++)
            {
                res.Add((n & reader) == reader);
                reader *= 2;
            }

            res.Reverse();

            return res.ToArray();
        }

        private byte bits_to_byte_with_bit_count(int index, byte bit_count)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + bit_count - 1 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            if (bit_count > 8)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть больше 8 бит.");

            if (bit_count < 1)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть меньше 1 бита.");

            byte res = 0;
            byte writer = 1;

            for (int i = bit_count - 1; i >= 0; i--)
            {
                if (content[index + i]) res = (byte)(res | writer);
                writer *= 2;
            }

            return res;
        }

        private int bits_to_int_with_bit_count(int index, byte bit_count)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + bit_count - 1 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            if (bit_count > 32)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть больше 32 бит.");

            if (bit_count < 1)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть меньше 1 бита.");

            int res = 0;
            int writer = 1;

            for (int i = bit_count - 1; i >= 0; i--)
            {
                if (content[index + i]) res = (res | writer);
                writer *= 2;
            }

            return res;
        }

        /// <summary>
        /// Инициализация пустого экземпляра массива битов.
        /// </summary>
        public BinaryType()
        {
            content = new List<bool>();
        }

        /// <summary>
        /// Инициализация экземпляра массива битов с одним начальным битом.
        /// </summary>
        /// <param name="bit">Тот самый начальный бит.</param>
        public BinaryType(bool bit)
        {
            content = new List<bool>();
            content.Add(bit);
        }

        /// <summary>
        /// Инициализация экземпляра массива битов с несколькими начальными битами.
        /// </summary>
        /// <param name="bits">Массив начальных битов.</param>
        public BinaryType(bool[] bits)
        {
            content = new List<bool>();
            add_bits(bits);
        }

        /// <summary>
        /// Инициализация экземпляра массива битов из байта.
        /// </summary>
        /// <param name="b">Байт, преобразуемый в массив битов.</param>
        public BinaryType(byte b)
        {
            content = new List<bool>();
            bool[] bits = byte_to_bits(b);
            add_bits(bits);
        }

        /// <summary>
        /// Инициализация экземпляра массива битов из массива байтов.
        /// </summary>
        /// <param name="bytes">Массив байтов, преобразуемый в массив битов.</param>
        public BinaryType(byte[] bytes)
        {
            content = new List<bool>();
            bool[] bits;

            foreach (byte i in bytes)
            {
                bits = byte_to_bits(i);
                add_bits(bits);
            }
        }

        /// <summary>
        /// Инициализация экземпляра массива битов из целого числа используя заданное количество бит.
        /// </summary>
        /// <param name="n">Число, преобразуемое в массив битов.</param>
        /// <param name="bit_count">Количество используемых бит.</param>
        public BinaryType(int n, byte bit_count)
        {
            if (bit_count > 32)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть больше 32 бит.");

            if (bit_count < 1)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть меньше 1 бита.");

            content = new List<bool>();
            bool[] bits = int_to_bits_with_bit_count(n, bit_count);
            add_bits(bits);
        }

        /// <summary>
        /// Инициализация экземпляра массива битов из байта используя заданное количество бит.
        /// </summary>
        /// <param name="n">Число, преобразуемое в массив битов.</param>
        /// <param name="bit_count">Количество используемых бит.</param>
        public BinaryType(byte n, byte bit_count)
        {
            if (bit_count > 8)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть больше 8 бит.");

            if (bit_count < 1)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть меньше 1 бита.");

            content = new List<bool>();
            bool[] bits = byte_to_bits_with_bit_count(n, bit_count);
            add_bits(bits);
        }

        /// <summary>
        /// Инициализация экземпляра массива битов из массива байтов
        /// с указанным количеством битов на байт.
        /// </summary>
        /// <param name="bytes">Массив байтов, преобразуемый в массив битов.</param>
        /// <param name="bit_count">Количество бит на 1 байт.</param>
        public BinaryType(byte[] bytes, byte bit_count)
        {
            if (bit_count > 8)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть больше 8 бит.");

            if (bit_count < 1)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть меньше 1 бита.");

            content = new List<bool>();
            bool[] bits;

            foreach (byte i in bytes)
            {
                bits = byte_to_bits_with_bit_count(i, bit_count);
                add_bits(bits);
            }
        }

        /// <summary>
        /// Возвращает массив битов в строковом представлении.
        /// </summary>
        /// <returns>Массив битов (0 и 1).</returns>
        public override string ToString()
        {
            StringBuilder s = new StringBuilder();

            foreach (bool i in content)
            {
                if (i) s.Append("1 ");
                else s.Append("0 ");
            }

            return s.ToString();
        }

        /// <summary>
        /// Добавление бита.
        /// </summary>
        /// <param name="bit">Добавляемый бит.</param>
        public void Add(bool bit)
        {
            content.Add(bit);
        }

        /// <summary>
        /// Добавление массива битов.
        /// </summary>
        /// <param name="bits">Добавляемый массив битов.</param>
        public void Add(bool[] bits)
        {
            add_bits(bits);
        }

        /// <summary>
        /// Добавление байта (в виде битов).
        /// </summary>
        /// <param name="b">Добавляемый байт.</param>
        public void Add(byte b)
        {
            bool[] bits = byte_to_bits(b);
            add_bits(bits);
        }

        /// <summary>
        /// Добавление массива байтов (в виде битов).
        /// </summary>
        /// <param name="bytes">Добавляемый массив байтов.</param>
        public void Add(byte[] bytes)
        {
            bool[] bits;

            foreach (byte i in bytes)
            {
                bits = byte_to_bits(i);
                add_bits(bits);
            }
        }

        /// <summary>
        /// Добавление массива битов из байта используя заданное количество бит.
        /// </summary>
        /// <param name="n">Число, преобразуемое в массив битов.</param>
        /// <param name="bit_count">Количество используемых бит.</param>
        public void Add(byte n, byte bit_count)
        {
            if (bit_count > 8)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть больше 8 бит.");

            if (bit_count < 1)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть меньше 1 бита.");

            bool[] bits = byte_to_bits_with_bit_count(n, bit_count);
            add_bits(bits);
        }

        /// <summary>
        /// Добавление массива битов из массива байтов
        /// с указанным количеством битов на байт.
        /// </summary>
        /// <param name="bytes">Массив байтов, преобразуемый в массив битов.</param>
        /// <param name="bit_count">Количество бит на 1 байт.</param>
        public void Add(byte[] bytes, byte bit_count)
        {
            if (bit_count > 8)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть больше 8 бит.");

            if (bit_count < 1)
                throw new ArgumentOutOfRangeException("bit_count", "В байте не может быть меньше 1 бита.");

            bool[] bits;

            foreach (byte i in bytes)
            {
                bits = byte_to_bits_with_bit_count(i, bit_count);
                add_bits(bits);
            }
        }

        /// <summary>
        /// Удаление последнего элемента.
        /// </summary>
        public void RemoveLast()
        {
            if (content.Count < 1)
                throw new Exception("Нечего удалять.");
            content.RemoveAt(content.Count - 1);
        }

        /// <summary>
        /// Удаление элемента по указанному индексу.
        /// </summary>
        /// <param name="index">Индекс удаляемого файла.</param>
        public void RemoveAt(int index)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Индекс находится вне границ массива.");
            content.RemoveAt(content.Count - 1);
        }

        /// <summary>
        /// Удалить из массива некоторое количество бит, начиная с указанного адреса.
        /// </summary>
        /// <param name="index">Стартовый индекс.</param>
        /// <param name="lenght">Количество удаляемых элементов.</param>
        public void RemoveRange(int index, int lenght)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Индекс находится вне границ массива.");

            if (index + lenght >= content.Count)
                throw new Exception("Для указанных index и length элементы находятся вне границ массива.");

            content.RemoveRange(index, lenght);
        }

        /// <summary>
        /// Позволяет получить или задать значение массива битов по индексу.
        /// </summary>
        /// <param name="index">Индекс значения в массиве.</param>
        public bool this[int index]
        {
            get
            {
                if (index < 0)
                    throw new ArgumentOutOfRangeException("index");

                if (index >= content.Count)
                    throw new ArgumentOutOfRangeException("index", "Индекс находится вне границ массива.");

                return content[index];
            }
            set
            {
                content[index] = value;
            }
        }

        /// <summary>
        /// Получение массива битов.
        /// </summary>
        /// <returns>bool[]</returns>
        public bool[] ToArray_bool()
        {
            return content.ToArray();
        }

        /// <summary>
        /// Перевод массива битов в массив байтов.
        /// Если количество бит в массиве не будет кратным 8, то в начале автоматически будет добавлено нужное количество бит.
        /// </summary>
        /// <returns>byte[]</returns>
        public byte[] ToArray_byte()
        {
            if (content.Count % 8 != 0)
            {
                int q = content.Count % 8;
                for (int i = 0; i < q; i++)
                {
                    content.Insert(0, false);
                }
            }

            int length = content.Count / 8;

            byte[] res = new byte[length];

            for (int i = 0; i < length; i++)
            {
                res[i] = bits_to_byte(i * 8);
            }

            return res;
        }

        /// <summary>
        /// Перевод массива битов в массив байтов с указанным числом битов на байт.
        /// Если количество бит в массиве не будет кратным указанному числу байт,
        /// то в начале автоматически будет добавлено нужное количество бит.
        /// </summary>
        /// <param name="bit_count">Количество битов на байт.</param>
        /// <returns>byte[]</returns>
        public byte[] ToArray_byte(byte bit_count)
        {
            if (content.Count % bit_count != 0)
            {
                int q = content.Count % bit_count;
                for (int i = 0; i < q; i++)
                {
                    content.Insert(0, false);
                }
            }

            int length = content.Count / bit_count;

            byte[] res = new byte[length];

            for (int i = 0; i < length; i++)
            {
                res[i] = bits_to_byte_with_bit_count(i * bit_count, bit_count);
            }

            return res;
        }

        /// <summary>
        /// Получение байта из 8 битов, начиная с указанного индекса.
        /// </summary>
        /// <param name="index">Начальный индекс.</param>
        /// <returns></returns>
        public byte GetByte(int index)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + 7 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            byte res = bits_to_byte(index);

            return res;
        }

        /// <summary>
        /// Возвращает байт с использованием заданного числа бит.
        /// </summary>
        /// <param name="index">Начальный индекс.</param>
        /// <param name="bit_count">Число бит.</param>
        /// <returns></returns>
        public byte GetByte(int index, byte bit_count)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + bit_count - 1 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            byte res = bits_to_byte_with_bit_count(index, bit_count);
            return res;
        }

        /// <summary>
        /// Получение целого числа из 32 битов, начиная с указанного индекса.
        /// </summary>
        /// <param name="index">Начальный индекс.</param>
        /// <returns></returns>
        public int GetInt32(int index)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + 31 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            int res = bits_to_int(index);

            return res;
        }

        /// <summary>
        /// Получение целого числа из указанного количества битов, начиная с указанного индекса.
        /// </summary>
        /// <param name="index">Начальный индекс.</param>
        /// <returns></returns>
        public int GetInt32(int index, byte bit_count)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            if (index >= content.Count)
                throw new ArgumentOutOfRangeException("index");

            if (index + bit_count - 1 >= content.Count)
                throw new ArgumentOutOfRangeException("index", "Для указанного начального индекса недостаточно битов.");

            int res = bits_to_int_with_bit_count(index, bit_count);

            return res;
        }
    }
}