// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Buffers;
using System.Diagnostics;
using System.IO.Pipelines;
 
namespace Microsoft.AspNetCore.ResponseCaching.Tests;
 
public class CachedResponseBodyTests
{
    private readonly int _timeout = Debugger.IsAttached ? -1 : 5000;
 
    [Fact]
    public void GetSegments()
    {
        var segments = new List<byte[]>();
        var body = new CachedResponseBody(segments, 0);
 
        Assert.Same(segments, body.Segments);
    }
 
    [Fact]
    public void GetLength()
    {
        var segments = new List<byte[]>();
        var body = new CachedResponseBody(segments, 42);
 
        Assert.Equal(42, body.Length);
    }
 
    [Fact]
    public async Task Copy_DoNothingWhenNoSegments()
    {
        var segments = new List<byte[]>();
        var receivedSegments = new List<byte[]>();
        var body = new CachedResponseBody(segments, 0);
 
        var pipe = new Pipe();
        using var cts = new CancellationTokenSource(_timeout);
 
        var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token);
        var copyTask = body.CopyToAsync(pipe.Writer, cts.Token).ContinueWith(_ => pipe.Writer.CompleteAsync());
 
        await Task.WhenAll(receiverTask, copyTask);
 
        Assert.Empty(receivedSegments);
    }
 
    [Fact]
    public async Task Copy_SingleSegment()
    {
        var segments = new List<byte[]>
            {
                new byte[] { 1 }
            };
        var receivedSegments = new List<byte[]>();
        var body = new CachedResponseBody(segments, 0);
 
        var pipe = new Pipe();
 
        using var cts = new CancellationTokenSource(_timeout);
 
        var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token);
        var copyTask = CopyDataAsync(body, pipe.Writer, cts.Token);
 
        await Task.WhenAll(receiverTask, copyTask);
 
        Assert.Equal(segments, receivedSegments);
    }
 
    [Fact]
    public async Task Copy_MultipleSegments()
    {
        var segments = new List<byte[]>
            {
                new byte[] { 1 },
                new byte[] { 2, 3 }
            };
        var receivedSegments = new List<byte[]>();
        var body = new CachedResponseBody(segments, 0);
 
        var pipe = new Pipe();
 
        using var cts = new CancellationTokenSource(_timeout);
 
        var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token);
        var copyTask = CopyDataAsync(body, pipe.Writer, cts.Token);
 
        await Task.WhenAll(receiverTask, copyTask);
 
        Assert.Equal(new byte[] { 1, 2, 3 }, receivedSegments.SelectMany(x => x).ToArray());
    }
 
    static async Task CopyDataAsync(CachedResponseBody body, PipeWriter writer, CancellationToken cancellationToken)
    {
        await body.CopyToAsync(writer, cancellationToken);
        await writer.CompleteAsync();
    }
 
    static async Task ReceiveDataAsync(PipeReader reader, List<byte[]> receivedSegments, CancellationToken cancellationToken)
    {
        while (true)
        {
            var result = await reader.ReadAsync(cancellationToken);
            var buffer = result.Buffer;
 
            foreach (var memory in buffer)
            {
                receivedSegments.Add(memory.ToArray());
            }
 
            reader.AdvanceTo(buffer.End, buffer.End);
 
            if (result.IsCompleted)
            {
                break;
            }
        }
        await reader.CompleteAsync();
    }
}