using Sharp.NetServer.Middleware;

namespace NetServer.Test.UnitTests;

/// <summary>
/// 中间件管道测试（简化版）
/// </summary>
[TestClass]
public class MiddlewarePipelineTests
{
    [TestMethod]
    public async Task Pipeline_ShouldExecuteMiddlewaresInOrder()
    {
        // Arrange
        var pipeline = new MiddlewarePipeline();
        var executionOrder = new List<string>();

        pipeline.Use(next => async context =>
        {
            executionOrder.Add("First-Before");
            await next(context);
            executionOrder.Add("First-After");
        });

        pipeline.Use(next => async context =>
        {
            executionOrder.Add("Second-Before");
            await next(context);
            executionOrder.Add("Second-After");
        });

        pipeline.Use(next => async context => { executionOrder.Add("Third"); });

        // Act
        await pipeline.ExecuteAsync(null!); // 简化测试，不需要真实 context

        // Assert
        Assert.AreEqual(5, executionOrder.Count);
        Assert.AreEqual("First-Before", executionOrder[0]);
        Assert.AreEqual("Second-Before", executionOrder[1]);
        Assert.AreEqual("Third", executionOrder[2]);
        Assert.AreEqual("Second-After", executionOrder[3]);
        Assert.AreEqual("First-After", executionOrder[4]);
    }

    [TestMethod]
    public async Task Pipeline_ShouldSupportMultipleMiddlewares()
    {
        // Arrange
        var pipeline = new MiddlewarePipeline();
        var counter = 0;

        for (var i = 0; i < 5; i++)
            pipeline.Use(next => async context =>
            {
                counter++;
                await next(context);
            });

        // Act
        await pipeline.ExecuteAsync(null!);

        // Assert
        Assert.AreEqual(5, counter);
    }

    [TestMethod]
    public async Task Pipeline_CanShortCircuit()
    {
        // Arrange
        var pipeline = new MiddlewarePipeline();
        var reachedEnd = false;

        pipeline.Use(next => async context =>
        {
            // 短路，不调用 next
            await Task.CompletedTask;
        });

        pipeline.Use(next => async context =>
        {
            reachedEnd = true;
            await next(context);
        });

        // Act
        await pipeline.ExecuteAsync(null!);

        // Assert
        Assert.IsFalse(reachedEnd, "Pipeline should be short-circuited");
    }
}