// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using Microsoft.AspNetCore.Http;

namespace Microsoft.AspNetCore.ResponseCompression.Tests;

public class ResponseCompressionBodyTest
{
    [Theory]
    [InlineData(null, "Accept-Encoding")]
    [InlineData("", "Accept-Encoding")]
    [InlineData("AnotherHeader", "AnotherHeader,Accept-Encoding")]
    [InlineData("Accept-Encoding", "Accept-Encoding")]
    [InlineData("accepT-encodinG", "accepT-encodinG")]
    [InlineData("accept-encoding,AnotherHeader", "accept-encoding,AnotherHeader")]
    public void OnWrite_AppendsAcceptEncodingToVaryHeader_IfNotPresent(string providedVaryHeader, string expectedVaryHeader)
    {
        var httpContext = new DefaultHttpContext();
        httpContext.Response.Headers.Vary = providedVaryHeader;
        var stream = new ResponseCompressionBody(httpContext, new MockResponseCompressionProvider(flushable: true), new StreamResponseBodyFeature(new MemoryStream()));

        stream.Write(new byte[] { }, 0, 0);

        Assert.Equal(expectedVaryHeader, httpContext.Response.Headers.Vary);
    }

    [Theory]
    [InlineData(true)]
    [InlineData(false)]
    public void Write_IsPassedToUnderlyingStream_WhenDisableResponseBuffering(bool flushable)
    {

        var buffer = new byte[] { 1 };

        var memoryStream = new MemoryStream();
        var stream = new ResponseCompressionBody(new DefaultHttpContext(), new MockResponseCompressionProvider(flushable), new StreamResponseBodyFeature(memoryStream));

        stream.DisableBuffering();
        stream.Write(buffer, 0, buffer.Length);

        Assert.Equal(buffer, memoryStream.ToArray());
    }

    [Theory]
    [InlineData(true)]
    [InlineData(false)]
    public async Task WriteAsync_IsPassedToUnderlyingStream_WhenDisableResponseBuffering(bool flushable)
    {
        var buffer = new byte[] { 1 };

        var memoryStream = new MemoryStream();
        var stream = new ResponseCompressionBody(new DefaultHttpContext(), new MockResponseCompressionProvider(flushable), new StreamResponseBodyFeature(memoryStream));

        stream.DisableBuffering();
        await stream.WriteAsync(buffer, 0, buffer.Length);

        Assert.Equal(buffer, memoryStream.ToArray());
    }

    [Fact]
    public async Task SendFileAsync_IsPassedToUnderlyingStream_WhenDisableResponseBuffering()
    {
        var memoryStream = new MemoryStream();

        var stream = new ResponseCompressionBody(new DefaultHttpContext(), new MockResponseCompressionProvider(true), new StreamResponseBodyFeature(memoryStream));

        stream.DisableBuffering();

        var path = "testfile1kb.txt";
        await stream.SendFileAsync(path, 0, null, CancellationToken.None);

        Assert.Equal(File.ReadAllBytes(path), memoryStream.ToArray());
    }

    [Theory]
    [InlineData(true)]
    [InlineData(false)]
    public void BeginWrite_IsPassedToUnderlyingStream_WhenDisableResponseBuffering(bool flushable)
    {
        var buffer = new byte[] { 1 };

        var memoryStream = new MemoryStream();

        var stream = new ResponseCompressionBody(new DefaultHttpContext(), new MockResponseCompressionProvider(flushable), new StreamResponseBodyFeature(memoryStream));

        stream.DisableBuffering();
        stream.BeginWrite(buffer, 0, buffer.Length, (o) => { }, null);

        Assert.Equal(buffer, memoryStream.ToArray());
    }

    private class MockResponseCompressionProvider : IResponseCompressionProvider
    {
        private readonly bool _flushable;

        public MockResponseCompressionProvider(bool flushable)
        {
            _flushable = flushable;
        }

        public ICompressionProvider GetCompressionProvider(HttpContext context)
        {
            return new MockCompressionProvider(_flushable);
        }

        public bool ShouldCompressResponse(HttpContext context)
        {
            return true;
        }

        public bool CheckRequestAcceptsCompression(HttpContext context)
        {
            return true;
        }
    }

    private class MockCompressionProvider : ICompressionProvider
    {
        public MockCompressionProvider(bool flushable)
        {
            SupportsFlush = flushable;
        }

        public string EncodingName { get; }

        public bool SupportsFlush { get; }

        public Stream CreateStream(Stream outputStream)
        {
            if (SupportsFlush)
            {
                return new BufferedStream(outputStream);
            }
            else
            {
                return new NoFlushBufferedStream(outputStream);
            }

        }
    }

    private class NoFlushBufferedStream : Stream
    {
        private readonly BufferedStream _bufferedStream;

        public NoFlushBufferedStream(Stream outputStream)
        {
            _bufferedStream = new BufferedStream(outputStream);
        }

        public override void Flush()
        {
        }

        public override int Read(byte[] buffer, int offset, int count) => _bufferedStream.Read(buffer, offset, count);

        public override long Seek(long offset, SeekOrigin origin) => _bufferedStream.Seek(offset, origin);

        public override void SetLength(long value) => _bufferedStream.SetLength(value);

        public override void Write(byte[] buffer, int offset, int count) => _bufferedStream.Write(buffer, offset, count);

        public override bool CanRead => _bufferedStream.CanRead;

        public override bool CanSeek => _bufferedStream.CanSeek;

        public override bool CanWrite => _bufferedStream.CanWrite;

        public override long Length => _bufferedStream.Length;

        public override long Position
        {
            get { return _bufferedStream.Position; }
            set { _bufferedStream.Position = value; }
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            _bufferedStream.Flush();
        }
    }
}
