using System;

namespace Amphora.RandomComparisons
{
    /// <summary>
    /// Which end of a 64-bit word a check reads.  Generators differ most in their lowest bits, so every check runs on
    /// both.
    /// </summary>
    public enum Window
    {
        High,
        Low,
    }

    public static class Windows
    {
        /// <summary>
        /// Returns the top or bottom <paramref name="bits"/> bits of the word as a number.
        /// </summary>
        public static ulong Take(ulong word, Window window, int bits)
        {
            if (window == Window.High)
            {
                return word >> (64 - bits);
            }

            return word & ((1UL << bits) - 1);
        }

        /// <summary>
        /// Returns the bit of the word at the window's outer edge, 0 or 1.
        /// </summary>
        public static int EdgeBit(ulong word, Window window)
        {
            return (int)Take(word, window, 1);
        }
    }

    /// <summary>
    /// Makes 64-bit words in the order a generator draws them.
    /// </summary>
    public abstract class WordSource
    {
        public abstract void Fill(ulong[] buffer, int start, int count);
    }

    /// <summary>
    /// Reads a WordSource one word at a time, so a check can ask for exactly as many as it needs.
    /// </summary>
    public sealed class WordStream
    {
        public const int BufferLength = 4096;

        private readonly WordSource source;
        private readonly ulong[] buffer = new ulong[BufferLength];
        private int position = BufferLength;

        public WordStream(WordSource source)
        {
            this.source = source;
        }

        public ulong Next()
        {
            if (position == BufferLength)
            {
                source.Fill(buffer, 0, BufferLength);
                position = 0;
            }

            ulong returnMe = buffer[position];
            position++;
            return returnMe;
        }
    }

    /// <summary>
    /// The words of one of Amphora's generators, or a control, through the same interface.
    /// </summary>
    public sealed class GeneratorWords<GeneratorType> : WordSource
        where GeneratorType : struct, IRandomGenerator
    {
        private GeneratorType generator;

        public GeneratorWords(GeneratorType generator)
        {
            this.generator = generator;
        }

        public override void Fill(ulong[] buffer, int start, int count)
        {
            for (int i = 0; i < count; i++)
            {
                buffer[start + i] = generator.NextUInt64();
            }
        }
    }

    /// <summary>
    /// The words of System.Random, which has no 64-bit draw, so they are eight of its bytes.
    /// </summary>
    public sealed class SystemRandomWords : WordSource
    {
        private readonly Random random;
        private readonly byte[] bytes = new byte[8];

        public SystemRandomWords(ulong seed)
        {
            random = new Random((int)(seed ^ (seed >> 32)));
        }

        public override void Fill(ulong[] buffer, int start, int count)
        {
            for (int i = 0; i < count; i++)
            {
                random.NextBytes(bytes);
                buffer[start + i] = BitConverter.ToUInt64(bytes, 0);
            }
        }
    }

    /// <summary>
    /// The first few words of a generator started at each of a run of adjacent seeds, one seed after another.  This is
    /// how a seed's neighbors look when a program starts many generators from consecutive numbers.
    /// </summary>
    public sealed class AdjacentSeedWords : WordSource
    {
        private readonly Func<ulong, WordSource> make;
        private readonly int wordsPerSeed;
        private ulong nextSeed;

        public AdjacentSeedWords(Func<ulong, WordSource> make, ulong firstSeed, int wordsPerSeed)
        {
            this.make = make;
            this.wordsPerSeed = wordsPerSeed;
            nextSeed = firstSeed;
        }

        public override void Fill(ulong[] buffer, int start, int count)
        {
            if (count % wordsPerSeed != 0)
            {
                throw new ArgumentException("A fill must hold a whole number of seeds' words.", nameof(count));
            }

            for (int offset = 0; offset < count; offset += wordsPerSeed)
            {
                make(nextSeed).Fill(buffer, start + offset, wordsPerSeed);
                nextSeed++;
            }
        }
    }

    /// <summary>
    /// The words of several streams taken in turn, one from each, the way parallel streams would feed one consumer.
    /// </summary>
    public sealed class InterleavedWords : WordSource
    {
        private readonly WordStream[] streams;
        private int next;

        public InterleavedWords(WordSource[] sources)
        {
            streams = new WordStream[sources.Length];
            for (int i = 0; i < sources.Length; i++)
            {
                streams[i] = new WordStream(sources[i]);
            }
        }

        public override void Fill(ulong[] buffer, int start, int count)
        {
            for (int i = 0; i < count; i++)
            {
                buffer[start + i] = streams[next].Next();
                next++;
                if (next == streams.Length)
                {
                    next = 0;
                }
            }
        }
    }

    public delegate void JumpFunction<GeneratorType>(ref GeneratorType generator);
}