using Amphora;
using System.IO;
using System.Linq;
using UnitTestSharp;
using static Susurrus.UnitTests.TestSounds;

namespace Susurrus.UnitTests
{
    public class StreamBytesTests : TestFixture
    {
        public const int FirstGrowthSize = 65536;

        public static byte[] Counting(int length)
        {
            byte[] returnMe = new byte[length];

            for (int i = 0; i < length; ++i)
            {
                returnMe[i] = (byte)i;
            }

            return returnMe;
        }

        public class ReadAtMostTests : TestFixture
        {
            public void FillsTheBufferFromAStreamThatGivesFewBytesPerRead()
            {
                byte[] buffer = new byte[6];

                CheckEqual(6, StreamBytes.ReadAtMost(new TrickleStream(Counting(10), bytesPerRead: 3), buffer));
                CheckEqual(new byte[] { 0, 1, 2, 3, 4, 5 }, buffer);
            }

            public void StopsAtTheEndOfTheStream()
            {
                byte[] buffer = new byte[6];

                CheckEqual(4, StreamBytes.ReadAtMost(new MemoryStream(Counting(4)), buffer));
            }

            public void StartsFillingAtTheOffsetAndCountsOnlyWhatItRead()
            {
                byte[] buffer = new byte[6];

                CheckEqual(4, StreamBytes.ReadAtMost(new MemoryStream(Counting(10)), buffer, offset: 2));
                CheckEqual(new byte[] { 0, 0, 0, 1, 2, 3 }, buffer);
            }

            public void AnEmptyBuffer_ReadsNothing()
            {
                CheckEqual(0, StreamBytes.ReadAtMost(new MemoryStream(Counting(4)), new byte[0]));
            }
        }

        public class SkipTests : TestFixture
        {
            public void SeekableStream_MovesForward()
            {
                MemoryStream stream = new MemoryStream(Counting(10));

                StreamBytes.Skip(stream, 4);

                CheckEqual(4L, stream.Position);
            }

            public void SeekableStream_StopsAtItsEnd()
            {
                MemoryStream stream = new MemoryStream(Counting(10));

                StreamBytes.Skip(stream, 99);

                CheckEqual(10L, stream.Position);
            }

            public void ForwardOnlyStream_DiscardsTheBytes()
            {
                Stream stream = new TrickleStream(Counting(10), bytesPerRead: 2);

                StreamBytes.Skip(stream, 4);

                CheckEqual(4, stream.ReadByte());
            }

            public void ForwardOnlyStream_SkipsMoreThanItsDiscardBufferHolds()
            {
                Stream stream = new TrickleStream(Counting(10000), bytesPerRead: 3000);

                StreamBytes.Skip(stream, 9000);

                CheckEqual(9000 % 256, stream.ReadByte());
            }

            public void ForwardOnlyStream_StopsAtItsEnd()
            {
                Stream stream = new TrickleStream(Counting(10), bytesPerRead: 4);

                StreamBytes.Skip(stream, 99);

                CheckEqual(-1, stream.ReadByte());
            }

            public void ForwardOnlyStream_SkippingNothing_LeavesItWhereItIs()
            {
                Stream stream = new TrickleStream(Counting(10), bytesPerRead: 4);

                StreamBytes.Skip(stream, 0);

                CheckEqual(0, stream.ReadByte());
            }
        }

        public class ReadBlockTests : TestFixture
        {
            public void SeekableStream_ReturnsTheNextBytes()
            {
                MemoryStream stream = new MemoryStream(Counting(10));
                stream.Position = 2;

                CheckEqual(new byte[] { 2, 3, 4 }, BytesOf(StreamBytes.ReadBlock(stream, 3)));
            }

            public void SeekableStreamClaimingMoreThanItHolds_ReturnsADefaultViewWithoutAllocatingTheClaim()
            {
                CheckTrue(StreamBytes.ReadBlock(new MemoryStream(Counting(10)), int.MaxValue).IsDefault);
            }

            public void SeekableStreamThatEndsBeforeItsLength_ReturnsADefaultView()
            {
                ClaimedLengthStream stream = new ClaimedLengthStream(Counting(5), claimedLength: 10);

                CheckTrue(StreamBytes.ReadBlock(stream, 10).IsDefault);
            }

            public void SeekableStream_AskedForNothing_ReturnsAnEmptyArray()
            {
                CheckEqual(0, StreamBytes.ReadBlock(new MemoryStream(Counting(10)), 0).Length);
            }

            public void ForwardOnlyStream_ReturnsTheNextBytes()
            {
                Stream stream = new TrickleStream(Counting(10), bytesPerRead: 3);

                CheckEqual(Counting(10), BytesOf(StreamBytes.ReadBlock(stream, 10)));
            }

            public void ForwardOnlyStream_AskedForNothing_ReturnsAnEmptyArray()
            {
                CheckEqual(0, StreamBytes.ReadBlock(new TrickleStream(Counting(10), 3), 0).Length);
            }

            public void ForwardOnlyStreamEndingEarly_ReturnsADefaultView()
            {
                CheckTrue(StreamBytes.ReadBlock(new TrickleStream(Counting(5), bytesPerRead: 2), 10).IsDefault);
            }

            public void ForwardOnlyStreamClaimingMoreThanItHolds_ReturnsADefaultViewWithoutAllocatingTheClaim()
            {
                CheckTrue(StreamBytes.ReadBlock(new TrickleStream(Counting(10), bytesPerRead: 4),
                    int.MaxValue).IsDefault);
            }

            public void ForwardOnlyStreamOfExactlyTheFirstGrowthStep_ReturnsEveryByte()
            {
                Stream stream = new TrickleStream(Counting(FirstGrowthSize), bytesPerRead: 4096);

                CheckTrue(Counting(FirstGrowthSize).SequenceEqual(
                    BytesOf(StreamBytes.ReadBlock(stream, FirstGrowthSize))));
            }

            public void ForwardOnlyStreamLargerThanTheFirstGrowthStep_ReturnsEveryByte()
            {
                Stream stream = new TrickleStream(Counting(70000), bytesPerRead: 4096);

                CheckTrue(Counting(70000).SequenceEqual(BytesOf(StreamBytes.ReadBlock(stream, 70000))));
            }

            public void ForwardOnlyStreamLargerThanTwoGrowthSteps_ReturnsEveryByte()
            {
                Stream stream = new TrickleStream(Counting(150000), bytesPerRead: 8192);

                CheckTrue(Counting(150000).SequenceEqual(BytesOf(StreamBytes.ReadBlock(stream, 150000))));
            }
        }

        public class ReadRemainingTests : TestFixture
        {
            public void SeekableStream_ReturnsFromItsPositionToItsEnd()
            {
                MemoryStream stream = new MemoryStream(Counting(10));
                stream.Position = 7;

                CheckEqual(new byte[] { 7, 8, 9 }, BytesOf(StreamBytes.ReadRemaining(stream)));
            }

            public void SeekableStreamAtItsEnd_ReturnsAnEmptyArray()
            {
                MemoryStream stream = new MemoryStream(Counting(10));
                stream.Position = 10;

                CheckEqual(0, StreamBytes.ReadRemaining(stream).Length);
            }

            public void SeekableStreamLongerThanAnArrayCanHold_ReturnsADefaultView()
            {
                ClaimedLengthStream stream = new ClaimedLengthStream(Counting(10), claimedLength: 1L << 31);

                CheckTrue(StreamBytes.ReadRemaining(stream).IsDefault);
            }

            public void SeekableStreamHoldingLessThanItsLength_ReturnsWhatItHolds()
            {
                ClaimedLengthStream stream = new ClaimedLengthStream(Counting(10), claimedLength: 1000);

                CheckEqual(Counting(10), BytesOf(StreamBytes.ReadRemaining(stream)));
            }

            public void ForwardOnlyStream_ReturnsEveryByte()
            {
                Stream stream = new TrickleStream(Counting(10), bytesPerRead: 3);

                CheckEqual(Counting(10), BytesOf(StreamBytes.ReadRemaining(stream)));
            }

            public void EmptyForwardOnlyStream_ReturnsAnEmptyArray()
            {
                CheckEqual(0, StreamBytes.ReadRemaining(new TrickleStream(new byte[0], 3)).Length);
            }

            public void ForwardOnlyStreamOfExactlyTheFirstGrowthStep_ReturnsEveryByte()
            {
                Stream stream = new TrickleStream(Counting(FirstGrowthSize), bytesPerRead: 4096);

                CheckTrue(Counting(FirstGrowthSize).SequenceEqual(BytesOf(StreamBytes.ReadRemaining(stream))));
            }

            public void ForwardOnlyStreamLargerThanTheFirstGrowthStep_ReturnsEveryByte()
            {
                Stream stream = new TrickleStream(Counting(150000), bytesPerRead: 8192);

                CheckTrue(Counting(150000).SequenceEqual(BytesOf(StreamBytes.ReadRemaining(stream))));
            }
        }
    }
}