GrimoireRandom

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using GrimoireTactics.Framework.Maths;
using OpenTK.Graphics;

namespace GrimoireTactics.Framework.Probability
{
    /*
     * Someone needs to generate documentation for this.
     */
    public sealed class GrimoireRandom
    {
        //
        // Private Constants
        //
        private int _inext;
        private int _inextp;
        private int[] _seedArray = new int[56];
        private int _seed;

        public int Seed
        {
            get
            {
                return _seed;
            }
            set
            {
                _seed = value;
                int subtraction = (_seed == Int32.MinValue) ? Int32.MaxValue : Math.Abs(_seed);
                int mj = 161803398 - subtraction;
                _seedArray[55] = mj;
                int mk = 1;
                for (int i = 1; i < 55; i++)
                {
                    int ii = (21 * i) % 55;
                    _seedArray[ii] = mk;
                    mk = mj - mk;
                    if (mk < 0)
                    {
                        mk += Int32.MaxValue;
                    }
                    mj = _seedArray[ii];
                }
                for (int k = 1; k < 5; k++)
                {
                    for (int i = 1; i < 56; i++)
                    {
                        _seedArray[i] -= _seedArray[1 + (i + 30) % 55];
                        if (_seedArray[i] < 0)
                        {
                            _seedArray[i] += Int32.MaxValue;
                        }
                    }
                }
                _inext = 0;
                _inextp = 21;
            }
        }

        public GrimoireRandom()
          : this(Environment.TickCount)
        {
        }

        public GrimoireRandom(int seed)
        {
            Seed = seed;
        }

        #region Random Integer

        /// <summary>
        /// Nexts this instance.
        /// </summary>
        /// <returns></returns>
        public int GenerateInteger()
        {
            return InternalSample();
        }

        /// <summary>
        /// Nexts the specified maximum value.
        /// </summary>
        /// <param name="maxValue">The maximum value.</param>
        /// <returns></returns>
        /// <exception cref="ArgumentOutOfRangeException">Input must be greater than zero.</exception>
        public int GenerateInteger(int maxValue)
        {
            return (int) (Sample()*maxValue);
        }

        /// <summary>
        /// Nexts the specified minimum value.
        /// </summary>
        /// <param name="minValue">The minimum value.</param>
        /// <param name="maxValue">The maximum value.</param>
        /// <returns></returns>
        /// <exception cref="ArgumentOutOfRangeException">Input must be greater than zero.</exception>
        public int GenerateInteger(int minValue, int maxValue)
        {
            long range = (long) maxValue - minValue;
            if (range <= Int32.MaxValue)
            {
                return (int) (Sample()*range) + minValue;
            }
            int result = InternalSample();
            bool negative = (InternalSample()%2 == 0);
            if (negative)
            {
                result = -result;
            }
            double d = result;
            d += (Int32.MaxValue - 1);
            d /= 2*(uint) Int32.MaxValue - 1;
            return (int) ((long) (d*range) + minValue);
        }

        public int GenerateInteger(Range<int> range)
        {
            return GenerateInteger(range.Minimum,range.Maximum);
        }

        public void GenerateIntegers(int[] buffer)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateInteger();
            }
        }

        public int[] GenerateIntegers(int count)
        {
            int[] buffer = new int[count];
            GenerateIntegers(buffer);
            return buffer;
        }

        public void GenerateIntegers(int[] buffer, int maxValue)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateInteger(0,maxValue);
            }
        }

        public int[] GenerateIntegers(int count, int maxValue)
        {
            int[] buffer = new int[count];
            GenerateIntegers(buffer, maxValue);
            return buffer;
        }

        public void GenerateIntegers(int[] buffer, int minValue, int maxValue)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateInteger(minValue,maxValue);
            }
        }

        public int[] GenerateIntegers(int count, int minValue, int maxValue)
        {
            int[] buffer = new int[count];
            GenerateIntegers(buffer,minValue,maxValue);
            return buffer;
        }

        public void GenerateIntegers(int[] buffer, Range<int> range )
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateInteger(range.Minimum, range.Maximum);
            }
        }

        public int[] GenerateIntegers(int count, Range<int> range )
        {
            int[] buffer = new int[count];
            GenerateIntegers(buffer, range);
            return buffer;
        }

        #endregion

        #region Random Double

        /// <summary>
        /// Nexts the double.
        /// </summary>
        /// <returns></returns>
        public double GenerateDouble()
        {
            return Sample();
        }

        public double GenerateDouble(double minValue, double maxValue)
        {
            return GenerateDouble() * (maxValue - minValue) + minValue;
        }

        public double GenerateDouble(Range<double> range)
        {
            return GenerateDouble(range.Minimum, range.Maximum);
        }

        public void GenerateDoubles(double[] buffer)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateDouble();
            }
        }

        public double[] GenerateDoubles(int count)
        {
            double[] buffer = new double[count];
            GenerateDoubles(buffer);
            return buffer;
        }


        //
        public void GenerateDoubles(double[] buffer, double minValue, double maxValue)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateDouble(minValue,maxValue);
            }
        }

        public double[] GenerateDoubles(int count, double minValue, double maxValue)
        {
            double[] buffer = new double[count];
            GenerateDoubles(buffer,minValue,maxValue);
            return buffer;
        }

        //
        public void GenerateDoubles(double[] buffer, Range<double> range )
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateDouble(range);
            }
        }

        public double[] GenerateDoubles(int count, Range<double> range )
        {
            double[] buffer = new double[count];
            GenerateDoubles(buffer, range);
            return buffer;
        }

        #endregion

        #region Random Byte

        public byte GenerateByte()
        {
            return (byte) GenerateInteger(0, 256);
        }

        public byte GenerateByte(byte maxValue)
        {
            return (byte) GenerateInteger(0, maxValue);
        }

        public byte GenerateByte(byte minValue, byte maxValue)
        {
            return (byte)GenerateInteger(minValue, maxValue);
        }

        /// <summary>
        /// Nexts the bytes.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <exception cref="ArgumentNullException"></exception>
        public void GenerateBytes(byte[] buffer)
        {
            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateByte();
            }
        }

        /// <summary>
        /// Allocates an array with random Boolean values.
        /// </summary>
        /// <param name="count">The count.</param>
        /// <returns></returns>
        public byte[] GenerateBytes(int count)
        {
            byte[] buffer = new byte[count];
            GenerateBytes(buffer);
            return buffer;
        }

        /// <summary>
        /// Nexts the bytes.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="maxValue"></param>
        /// <exception cref="ArgumentNullException"></exception>
        public void GenerateBytes(byte[] buffer, byte maxValue)
        {
            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateByte( 0, maxValue);
            }
        }

        /// <summary>
        /// Allocates an array with random Boolean values.
        /// </summary>
        /// <param name="count">The count.</param>
        /// <param name="maxValue"></param>
        /// <returns></returns>
        public byte[] GenerateBytes(int count, byte maxValue)
        {
            byte[] buffer = new byte[count];
            GenerateBytes(buffer, maxValue);
            return buffer;
        }

        /// <summary>
        /// Nexts the bytes.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="minValue"></param>
        /// <param name="maxValue"></param>
        /// <exception cref="ArgumentNullException"></exception>
        public void GenerateBytes(byte[] buffer,byte minValue, byte maxValue)
        {
            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateByte(minValue, maxValue);
            }
        }

        /// <summary>
        /// Allocates an array with random Boolean values.
        /// </summary>
        /// <param name="count">The count.</param>
        /// <param name="minValue"></param>
        /// <param name="maxValue"></param>
        /// <returns></returns>
        public byte[] GenerateBytes(int count,byte minValue, byte maxValue)
        {
            byte[] buffer = new byte[count];
            GenerateBytes(buffer, minValue, maxValue);
            return buffer;
        }

        /// <summary>
        /// Nexts the bytes.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="range"></param>
        /// <exception cref="ArgumentNullException"></exception>
        public void GenerateBytes(byte[] buffer, Range<byte> range )
        {
            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateByte(range.Minimum, range.Maximum);
            }
        }

        /// <summary>
        /// Allocates an array with random Boolean values.
        /// </summary>
        /// <param name="count">The count.</param>
        /// <param name="range"></param>
        /// <returns></returns>
        public byte[] GenerateBytes(int count, Range<byte> range)
        {
            byte[] buffer = new byte[count];
            GenerateBytes(buffer,range);
            return buffer;
        }

        #endregion

        #region Random Bool

        /// <summary>
        /// Generates a Random Boolean value.
        /// </summary>
        /// <returns></returns>
        public bool GenerateBool()
        {
            return GenerateInteger(2) == 1;
        }

        /// <summary>
        /// Allocates an array with random Boolean values.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        /// <exception cref="ArgumentNullException"></exception>
        public void GenerateBools(bool[] buffer)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateBool();
            }
        }

        /// <summary>
        /// Allocates an array with random Boolean values.
        /// </summary>
        /// <param name="count">The count.</param>
        /// <returns></returns>
        public bool[] GenerateBools(int count)
        {
            bool[] buffer = new bool[count];
            GenerateBools(buffer);
            return buffer;
        }

        #endregion

        #region Random String

        public string GenerateString(char[] possibleCharacters, int length)
        {
            char[] buffer = new char[length];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = possibleCharacters[GenerateInteger(possibleCharacters.Length)];
            }
            return new string(buffer);
        }

        public string[] GenerateStrings(char[] possibleCharacters, int length, int count)
        {
            string[] buffer = new string[count];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateString(possibleCharacters, length);
            }
            return buffer;
        }

        #endregion

        #region Random Color

        public Color GenerateColor()
        {
            int red = GenerateInteger(0, 256);
            int green = GenerateInteger(0, 256);
            int blue = GenerateInteger(0, 256);
            return Color.FromArgb(255, red, green, blue);
        }

        public Color[] GenerateColors(int quantity)
        {
            Color[] buffer = new Color[quantity];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateColor();
            }
            return buffer;
        }

        public Color4 GenerateOpenGLColor()
        {
            return GenerateColor();
        }

        public Color4[] GenerateOpenGLColors(int quantity)
        {
            Color4[] buffer = new Color4[quantity];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateColor();
            }
            return buffer;
        }

        #endregion

        #region Randomization Functions

        /// <summary>
        /// Randomizes the specified list.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">The list.</param>
        public void Randomize<T>(List<T> list)
        {
            int n = list.Count;
            while (n > 1)
            {
                n--;
                int k = GenerateInteger(n + 1);
                T value = list[k];
                list[k] = list[n];
                list[n] = value;
            }
        }

        /// <summary>
        /// Randomizes the specified list.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">The list.</param>
        public void Randomize<T>(T[] list)
        {
            int n = list.Length;
            while (n > 1)
            {
                n--;
                int k = GenerateInteger(n + 1);
                T value = list[k];
                list[k] = list[n];
                list[n] = value;
            }
        }

        public T Choose<T>(T[] items)
        {
            return items[GenerateInteger(items.Length)];
        }

        public T[] Choose<T>(T[] items, int quantity)
        {
            T[] chosenItems = new T[quantity];
            for (int i = 0; i < chosenItems.Length; i++)
            {
                chosenItems[i] = Choose(items);
            }
            return chosenItems;
        }

        #endregion

        #region Probability Functions

        /// <summary>
        /// Nexts the probability.
        /// </summary>
        /// <param name="percent">The percent.</param>
        /// <returns></returns>
        public bool GenerateProbability(double percent)
        {
            if (percent >= 1.0)
            {
                return true;
            }
            if (percent <= 0.0)
            {
                return false;
            }
            return GenerateDouble() <= percent;
        }

        public void GenerateProbabilities(double percent, bool[] buffer)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = GenerateProbability(percent);
            }
        }

        public bool[] GenerateProbabilities(double percent, int count)
        {
            bool[] buffer = new bool[count];
            GenerateProbabilities(percent, buffer);
            return buffer;
        }

        #endregion

        #region Internals

        public double Sample()
        {
            return (InternalSample()*(1.0/ Int32.MaxValue));
        }

        private int InternalSample()
        {
            int locINext = _inext;
            int locINextp = _inextp;

            if (++locINext >= 56)
            {
                locINext = 1;
            }
            if (++locINextp >= 56)
            {
                locINextp = 1;
            }
            int retVal = _seedArray[locINext] - _seedArray[locINextp];
            if (retVal == Int32.MaxValue)
            {
                retVal--;
            }
            if (retVal < 0)
            {
                retVal += Int32.MaxValue;
            }
            _seedArray[locINext] = retVal;
            _inext = locINext;
            _inextp = locINextp;
            return retVal;
        }

        #endregion

    }
}