using System.Buffers;
using System.IO.Pipelines;
using System.Text;
using NATS.Server.Protocol;

namespace NATS.Server.Core.Tests;

public class ParserTests
{
    private static async Task<List<ParsedCommand>> ParseAsync(string input)
    {
        var pipe = new Pipe();
        var commands = new List<ParsedCommand>();

        // Write input to pipe
        var bytes = Encoding.ASCII.GetBytes(input);
        await pipe.Writer.WriteAsync(bytes);
        pipe.Writer.Complete();

        // Parse from pipe
        var parser = new NatsParser(maxPayload: NatsProtocol.MaxPayloadSize);
        while (true)
        {
            var result = await pipe.Reader.ReadAsync();
            var buffer = result.Buffer;

            while (parser.TryParse(ref buffer, out var cmd))
                commands.Add(cmd);

            pipe.Reader.AdvanceTo(buffer.Start, buffer.End);

            if (result.IsCompleted)
                break;
        }

        return commands;
    }

    [Fact]
    public async Task Parse_PING()
    {
        var cmds = await ParseAsync("PING\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Ping);
    }

    [Fact]
    public async Task Parse_PONG()
    {
        var cmds = await ParseAsync("PONG\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Pong);
    }

    [Fact]
    public async Task Parse_CONNECT()
    {
        var cmds = await ParseAsync("CONNECT {\"verbose\":false,\"echo\":true}\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Connect);
        Encoding.ASCII.GetString(cmds[0].Payload.ToArray()).ShouldContain("verbose");
    }

    [Fact]
    public async Task Parse_CONNECT_preserves_json_payload_bytes()
    {
        const string json = "{\"verbose\":false,\"echo\":true}";
        var cmds = await ParseAsync($"CONNECT {json}\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Connect);
        Encoding.ASCII.GetString(cmds[0].Payload.Span).ShouldBe(json);
    }

    [Fact]
    public async Task Parse_SUB_without_queue()
    {
        var cmds = await ParseAsync("SUB foo 1\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Sub);
        cmds[0].Subject.ShouldBe("foo");
        cmds[0].Queue.ShouldBeNull();
        cmds[0].Sid.ShouldBe("1");
    }

    [Fact]
    public async Task Parse_SUB_with_queue()
    {
        var cmds = await ParseAsync("SUB foo workers 1\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Sub);
        cmds[0].Subject.ShouldBe("foo");
        cmds[0].Queue.ShouldBe("workers");
        cmds[0].Sid.ShouldBe("1");
    }

    [Fact]
    public async Task Parse_UNSUB()
    {
        var cmds = await ParseAsync("UNSUB 1\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Unsub);
        cmds[0].Sid.ShouldBe("1");
        cmds[0].MaxMessages.ShouldBe(-1);
    }

    [Fact]
    public async Task Parse_UNSUB_with_max()
    {
        var cmds = await ParseAsync("UNSUB 1 5\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Unsub);
        cmds[0].Sid.ShouldBe("1");
        cmds[0].MaxMessages.ShouldBe(5);
    }

    [Fact]
    public async Task Parse_PUB_with_payload()
    {
        var cmds = await ParseAsync("PUB foo 5\r\nHello\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Pub);
        cmds[0].Subject.ShouldBe("foo");
        cmds[0].ReplyTo.ShouldBeNull();
        Encoding.ASCII.GetString(cmds[0].Payload.ToArray()).ShouldBe("Hello");
    }

    [Fact]
    public async Task Parse_PUB_with_reply()
    {
        var cmds = await ParseAsync("PUB foo reply 5\r\nHello\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Pub);
        cmds[0].Subject.ShouldBe("foo");
        cmds[0].ReplyTo.ShouldBe("reply");
        Encoding.ASCII.GetString(cmds[0].Payload.ToArray()).ShouldBe("Hello");
    }

    [Fact]
    public async Task Parse_multiple_commands()
    {
        var cmds = await ParseAsync("PING\r\nPONG\r\nSUB foo 1\r\n");
        cmds.Count.ShouldBe(3);
        cmds[0].Type.ShouldBe(CommandType.Ping);
        cmds[1].Type.ShouldBe(CommandType.Pong);
        cmds[2].Type.ShouldBe(CommandType.Sub);
    }

    [Fact]
    public async Task Parse_PUB_zero_payload()
    {
        var cmds = await ParseAsync("PUB foo 0\r\n\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Pub);
        cmds[0].Payload.ToArray().ShouldBeEmpty();
    }

    [Fact]
    public async Task Parse_split_PUB_payload_across_reads()
    {
        var pipe = new Pipe();
        var parser = new NatsParser(maxPayload: NatsProtocol.MaxPayloadSize);

        await pipe.Writer.WriteAsync(Encoding.ASCII.GetBytes("PUB foo 5\r\nHe"));

        var first = await pipe.Reader.ReadAsync();
        var firstBuffer = first.Buffer;
        parser.TryParse(ref firstBuffer, out _).ShouldBeFalse();
        pipe.Reader.AdvanceTo(firstBuffer.Start, firstBuffer.End);

        await pipe.Writer.WriteAsync(Encoding.ASCII.GetBytes("llo\r\n"));
        pipe.Writer.Complete();

        var second = await pipe.Reader.ReadAsync();
        var secondBuffer = second.Buffer;
        parser.TryParse(ref secondBuffer, out var cmd).ShouldBeTrue();
        cmd.Type.ShouldBe(CommandType.Pub);
        cmd.Subject.ShouldBe("foo");
        Encoding.ASCII.GetString(cmd.Payload.Span).ShouldBe("Hello");
        pipe.Reader.AdvanceTo(secondBuffer.Start, secondBuffer.End);
    }

    [Fact]
    public async Task Parse_case_insensitive()
    {
        var cmds = await ParseAsync("ping\r\npub FOO 3\r\nabc\r\n");
        cmds.Count.ShouldBe(2);
        cmds[0].Type.ShouldBe(CommandType.Ping);
        cmds[1].Type.ShouldBe(CommandType.Pub);
    }

    [Fact]
    public async Task Parse_HPUB()
    {
        // HPUB subject 12 17\r\nNATS/1.0\r\n\r\nHello\r\n
        var header = "NATS/1.0\r\n\r\n";
        var payload = "Hello";
        var total = header.Length + payload.Length;
        var cmds = await ParseAsync($"HPUB foo {header.Length} {total}\r\n{header}{payload}\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.HPub);
        cmds[0].Subject.ShouldBe("foo");
        cmds[0].HeaderSize.ShouldBe(header.Length);
    }

    [Fact]
    public async Task Parse_INFO()
    {
        var cmds = await ParseAsync("INFO {\"server_id\":\"test\"}\r\n");
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Info);
        Encoding.ASCII.GetString(cmds[0].Payload.Span).ShouldBe("{\"server_id\":\"test\"}");
    }

    // Mirrors Go TestParsePubArg: verifies subject, optional reply, and payload size
    // are parsed correctly across various combinations of spaces and tabs.
    // Reference: golang/nats-server/server/parser_test.go TestParsePubArg
    [Theory]
    [InlineData("PUB a 2\r\nok\r\n",           "a",   null,  "ok")]
    [InlineData("PUB foo 2\r\nok\r\n",          "foo", null,  "ok")]
    [InlineData("PUB foo  2\r\nok\r\n",         "foo", null,  "ok")]
    [InlineData("PUB  foo 2\r\nok\r\n",         "foo", null,  "ok")]
    [InlineData("PUB  foo  2\r\nok\r\n",        "foo", null,  "ok")]
    [InlineData("PUB foo bar 2\r\nok\r\n",      "foo", "bar", "ok")]
    [InlineData("PUB foo  bar  2\r\nok\r\n",    "foo", "bar", "ok")]
    [InlineData("PUB  foo bar 2\r\nok\r\n",     "foo", "bar", "ok")]
    [InlineData("PUB  foo  bar  2  \r\nok\r\n", "foo", "bar", "ok")]
    [InlineData("PUB a\t2\r\nok\r\n",           "a",   null,  "ok")]
    [InlineData("PUB foo\t2\r\nok\r\n",         "foo", null,  "ok")]
    [InlineData("PUB \tfoo\t2\r\nok\r\n",       "foo", null,  "ok")]
    [InlineData("PUB foo\t\t\t2\r\nok\r\n",     "foo", null,  "ok")]
    [InlineData("PUB foo\tbar\t2\r\nok\r\n",    "foo", "bar", "ok")]
    [InlineData("PUB foo\t\tbar\t\t2\r\nok\r\n","foo", "bar", "ok")]
    public async Task Parse_PUB_argument_variations(
        string input, string expectedSubject, string? expectedReply, string expectedPayload)
    {
        var cmds = await ParseAsync(input);
        cmds.ShouldHaveSingleItem();
        cmds[0].Type.ShouldBe(CommandType.Pub);
        cmds[0].Subject.ShouldBe(expectedSubject);
        cmds[0].ReplyTo.ShouldBe(expectedReply);
        Encoding.ASCII.GetString(cmds[0].Payload.ToArray()).ShouldBe(expectedPayload);
    }

    // Helper that parses a protocol string and expects a ProtocolViolationException to be thrown.
    private static async Task<Exception> ParseExpectingErrorAsync(string input)
    {
        var pipe = new Pipe();
        var bytes = Encoding.ASCII.GetBytes(input);
        await pipe.Writer.WriteAsync(bytes);
        pipe.Writer.Complete();

        var parser = new NatsParser(maxPayload: NatsProtocol.MaxPayloadSize);
        Exception? caught = null;
        try
        {
            while (true)
            {
                var result = await pipe.Reader.ReadAsync();
                var buffer = result.Buffer;

                while (parser.TryParse(ref buffer, out _))
                {
                    // consume successfully parsed commands
                }

                pipe.Reader.AdvanceTo(buffer.Start, buffer.End);

                if (result.IsCompleted)
                    break;
            }
        }
        catch (Exception ex)
        {
            caught = ex;
        }

        caught.ShouldNotBeNull("Expected a ProtocolViolationException but no exception was thrown.");
        return caught!;
    }

    // Mirrors Go TestShouldFail: malformed protocol inputs that the parser must reject.
    // The .NET parser signals errors by throwing ProtocolViolationException.
    // Note: "PIx", "PINx" and "UNSUB_2" are not included here because the .NET parser
    // uses 2-byte prefix matching (b0+b1) rather than Go's byte-by-byte state machine.
    // As a result, "PIx" matches "PI"→PING and is silently accepted, and "UNSUB_2"
    // parses as UNSUB with sid "_2" — these are intentional behavioral differences.
    // Reference: golang/nats-server/server/parser_test.go TestShouldFail
    [Theory]
    [InlineData("Px\r\n")]
    [InlineData(" PING\r\n")]
    [InlineData("SUB\r\n")]
    [InlineData("SUB  \r\n")]
    [InlineData("SUB foo\r\n")]
    [InlineData("PUB foo\r\n")]
    [InlineData("PUB  \r\n")]
    [InlineData("PUB foo bar       \r\n")]
    public async Task Parse_malformed_protocol_fails(string input)
    {
        var ex = await ParseExpectingErrorAsync(input);
        ex.ShouldBeOfType<ProtocolViolationException>();
    }

    // Mirrors Go TestMaxControlLine: a control line exceeding 4096 bytes must be rejected.
    // Reference: golang/nats-server/server/parser_test.go TestMaxControlLine
    [Fact]
    public async Task Parse_exceeding_max_control_line_fails()
    {
        // Build a PUB command whose control line (subject + size field) exceeds 4096 bytes.
        var longSubject = new string('a', NatsProtocol.MaxControlLineSize);
        var input = $"PUB {longSubject} 0\r\n\r\n";
        var ex = await ParseExpectingErrorAsync(input);
        ex.ShouldBeOfType<ProtocolViolationException>();
    }

    // Mirrors Go TestParsePubSizeOverflow: oversized decimal payload lengths
    // must be rejected during PUB argument parsing.
    // Reference: golang/nats-server/server/parser_test.go TestParsePubSizeOverflow
    [Fact]
    public async Task Parse_pub_size_overflow_fails()
    {
        var ex = await ParseExpectingErrorAsync("PUB foo 1234567890\r\n");
        ex.ShouldBeOfType<ProtocolViolationException>();
        ex.Message.ShouldContain("Invalid payload size");
    }
}