/src/lib.zig at 57ad36db2bf140474bc9daa1e4fff713e8e554a6

// Copyright 2025 Shota FUJI
//
// Licensed under the Zero-Clause BSD License or the Apache License, Version 2.0, at your option.
// You may not use, copy, modify, or distribute this file except according to those terms. You can
// find a copy of the Zero-Clause BSD License at LICENSES/0BSD.txt, and a copy of the Apache License,
// Version 2.0 at LICENSES/Apache-2.0.txt. You may also obtain a copy of the Zero-Clause BSD License
// at <https://opensource.org/license/0bsd> and a copy of the Apache License, Version 2.0 at
// <https://www.apache.org/licenses/LICENSE-2.0>
//
// SPDX-License-Identifier: 0BSD OR Apache-2.0
//
// ===
//
// Zig API.

//! MOO message is a message format used for communicating with Roon Server.
//! Encodes to and decodes from newline-delimited UTF-8 encoded plain text, like HTTP.
//! Newline character is LF (0xa) without CR character.
//!
//! MOO message consists of metadata, header and body: header is a list of key-values
//! that both key and value contains UTF-8 string value, and body is single UTF-8 string.
//! Typical MOO message have "Content-Type" header that describes how the message's body
//! is encoded. (e.g. "application/json")
//! The first line of MOO message is metadata line, which is in "MOO/VERSION VERB SERVICE"
//! format. SERVICE is delimited by slash.

const std = @import("std");

const HeaderParsingContext = struct {
    start_position: usize,
};

/// Metadata contains a MOO message's version and semantics.
/// Fields point to the source message bytes: freeing the source message bytes then
/// accessing fields results in use-after-free.
pub const Metadata = struct {
    /// Message schema version described in metadata line.
    version: u32 = 1,

    /// Verb described in metadata line. Verb consists of uppercase alphabets.
    /// @example: "REQUEST", "COMPLETE"
    verb: []const u8,

    /// Service name described in metadata line.
    service: []const u8,

    context: HeaderParsingContext,

    const signature = "MOO/";

    pub const ParseError = error{
        InvalidSignature,
        InvalidVersionNumber,
        InvalidVerb,
        InvalidService,
        NonUtf8ServiceName,
    };

    pub fn parse(message: []const u8) ParseError!@This() {
        var i: usize = 0;

        if (!std.mem.startsWith(u8, message, signature)) {
            return ParseError.InvalidSignature;
        }

        i += signature.len;

        const version = if (std.mem.indexOfScalarPos(u8, message, i, ' ')) |space_position| blk: {
            if (i == space_position) {
                return ParseError.InvalidVersionNumber;
            }

            const parsed = std.fmt.parseInt(u32, message[i..space_position], 10) catch return ParseError.InvalidVersionNumber;

            i = space_position + 1;

            break :blk parsed;
        } else {
            return ParseError.InvalidVersionNumber;
        };

        const verb = if (std.mem.indexOfScalarPos(u8, message, i, ' ')) |space_position| blk: {
            if (i == space_position) {
                return ParseError.InvalidVerb;
            }

            const s = message[i..space_position];

            for (s) |char| {
                if (char < 'A' or char > 'Z') {
                    return ParseError.InvalidVerb;
                }
            }

            i = space_position + 1;

            break :blk s;
        } else {
            return ParseError.InvalidVerb;
        };

        const line_delimiter_position = std.mem.indexOfScalarPos(u8, message, i, '\n') orelse message.len;

        const service = message[i..line_delimiter_position];
        if (service.len == 0) {
            return ParseError.InvalidService;
        }

        if (!std.unicode.utf8ValidateSlice(service)) {
            return ParseError.NonUtf8ServiceName;
        }

        return @This(){
            .version = version,
            .verb = verb,
            .service = service,
            .context = HeaderParsingContext{
                .start_position = line_delimiter_position + 1,
            },
        };
    }
};

test Metadata {
    {
        const metadata = try Metadata.parse("MOO/1 REQUEST foo/bar\n");
        try std.testing.expectEqual(1, metadata.version);
        try std.testing.expectEqualStrings("REQUEST", metadata.verb);
        try std.testing.expectEqualStrings("foo/bar", metadata.service);
    }

    {
        const metadata = try Metadata.parse("MOO/20 COMPLETE foo\n");
        try std.testing.expectEqual(20, metadata.version);
        try std.testing.expectEqualStrings("COMPLETE", metadata.verb);
        try std.testing.expectEqualStrings("foo", metadata.service);
    }
}

test "Metadata.parse() should reject invalid signature" {
    {
        const err = Metadata.parse("");
        try std.testing.expectError(Metadata.ParseError.InvalidSignature, err);
    }

    {
        const err = Metadata.parse("\n");
        try std.testing.expectError(Metadata.ParseError.InvalidSignature, err);
    }

    {
        const err = Metadata.parse("MOO1 REQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidSignature, err);
    }

    {
        const err = Metadata.parse("MEOW/1 REQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidSignature, err);
    }
}

test "Metadata.parse() should reject invalid version" {
    {
        const err = Metadata.parse("MOO/1.0 REQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVersionNumber, err);
    }

    {
        const err = Metadata.parse("MOO/-1 REQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVersionNumber, err);
    }

    {
        const err = Metadata.parse("MOO/ REQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVersionNumber, err);
    }

    {
        const err = Metadata.parse("MOO/0x1 REQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVersionNumber, err);
    }

    {
        const err = Metadata.parse("MOO/one REQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVersionNumber, err);
    }
}

test "Metadata.parse() should reject invalid verb" {
    {
        const err = Metadata.parse("MOO/1 request foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVerb, err);
    }

    {
        const err = Metadata.parse("MOO/1 RÉQUEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVerb, err);
    }

    {
        const err = Metadata.parse("MOO/1 REQUEST1 foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVerb, err);
    }

    {
        const err = Metadata.parse("MOO/1 RE❓️UEST foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVerb, err);
    }

    {
        const err = Metadata.parse("MOO/1 \n");
        try std.testing.expectError(Metadata.ParseError.InvalidVerb, err);
    }

    {
        const err = Metadata.parse("MOO/1 foo/bar\n");
        try std.testing.expectError(Metadata.ParseError.InvalidVerb, err);
    }
}

test "Metadata.parse() should reject invalid service" {
    {
        const err = Metadata.parse("MOO/1 REQUEST \n");
        try std.testing.expectError(Metadata.ParseError.InvalidService, err);
    }

    {
        const err = Metadata.parse("MOO/1 REQUEST ");
        try std.testing.expectError(Metadata.ParseError.InvalidService, err);
    }

    {
        const err = Metadata.parse("MOO/1 REQUEST \xc3\x28\n");
        try std.testing.expectError(Metadata.ParseError.NonUtf8ServiceName, err);
    }
}

const HeaderIterator = struct {
    buffer: []const u8,

    pub const IterateError = error{
        NoHeaderDelimiterError,
        EmptyHeaderKey,
        NonUtf8HeaderKey,
        NonUtf8HeaderValue,
    };

    /// Returns bytes read when a header is read, `key` and `value` is populated.
    /// Returns `null` when the buffer is exhausted, `key` and `value` is untouched.
    pub fn iterate(self: *HeaderIterator, key: *[]const u8, value: *[]const u8) IterateError!?usize {
        if (self.buffer.len == 0) {
            return null;
        }

        const line_end = std.mem.indexOfScalar(u8, self.buffer, '\n') orelse self.buffer.len;
        const line = self.buffer[0..line_end];
        if (line.len == 0) {
            return null;
        }

        const delimiter = std.mem.indexOfScalar(u8, self.buffer, ':') orelse return IterateError.NoHeaderDelimiterError;

        const key_slice = self.buffer[0..delimiter];
        if (key_slice.len == 0) {
            return IterateError.EmptyHeaderKey;
        }

        if (!std.unicode.utf8ValidateSlice(key_slice)) {
            return IterateError.NonUtf8HeaderKey;
        }

        const value_slice = std.mem.trimLeft(u8, self.buffer[delimiter + 1 .. line_end], " ");
        if (!std.unicode.utf8ValidateSlice(value_slice)) {
            return IterateError.NonUtf8HeaderKey;
        }

        key.* = key_slice;
        value.* = value_slice;

        const read = @min(line_end + 1, self.buffer.len);

        self.buffer = self.buffer[read..];

        return read;
    }
};

test "(HeaderIterator).iterate should parse a header line" {
    var iter = HeaderIterator{ .buffer = "Foo: Bar\n" };

    var foo: []const u8 = undefined;
    var bar: []const u8 = undefined;
    const read = try iter.iterate(&foo, &bar);

    try std.testing.expectEqual(9, read);
    try std.testing.expectEqualStrings("Foo", foo);
    try std.testing.expectEqualStrings("Bar", bar);

    var key: []const u8 = undefined;
    var val: []const u8 = undefined;
    const second_read = try iter.iterate(&key, &val);

    try std.testing.expectEqual(null, second_read);
}

test "(HeaderIterator).iterate should parse header lines" {
    var iter = HeaderIterator{ .buffer = "Foo: foo-value\nbar: bar-value\nbaZ: baz-value\n" };

    var foo_key: []const u8 = undefined;
    var foo_value: []const u8 = undefined;
    const foo_read = try iter.iterate(&foo_key, &foo_value);

    try std.testing.expectEqual(15, foo_read);
    try std.testing.expectEqualStrings("Foo", foo_key);
    try std.testing.expectEqualStrings("foo-value", foo_value);

    var bar_key: []const u8 = undefined;
    var bar_value: []const u8 = undefined;
    const bar_read = try iter.iterate(&bar_key, &bar_value);

    try std.testing.expectEqual(15, bar_read);
    try std.testing.expectEqualStrings("bar", bar_key);
    try std.testing.expectEqualStrings("bar-value", bar_value);

    var baz_key: []const u8 = undefined;
    var baz_value: []const u8 = undefined;
    const baz_read = try iter.iterate(&baz_key, &baz_value);

    try std.testing.expectEqual(15, baz_read);
    try std.testing.expectEqualStrings("baZ", baz_key);
    try std.testing.expectEqualStrings("baz-value", baz_value);

    var key: []const u8 = undefined;
    var val: []const u8 = undefined;
    const final_read = try iter.iterate(&key, &val);

    try std.testing.expectEqual(null, final_read);
}

test "(HeaderIterator).iterate should parse a header line terminated without newline" {
    var iter = HeaderIterator{ .buffer = "Foo: Bar" };

    var foo: []const u8 = undefined;
    var bar: []const u8 = undefined;
    const read = try iter.iterate(&foo, &bar);

    try std.testing.expectEqual(8, read);
    try std.testing.expectEqualStrings("Foo", foo);
    try std.testing.expectEqualStrings("Bar", bar);

    var key: []const u8 = undefined;
    var val: []const u8 = undefined;
    const second_read = try iter.iterate(&key, &val);

    try std.testing.expectEqual(null, second_read);
}

test "(HeaderIterator).iterate should return false for blank inputs" {
    {
        var iter = HeaderIterator{ .buffer = "" };

        var key: []const u8 = undefined;
        var val: []const u8 = undefined;
        const read = try iter.iterate(&key, &val);

        try std.testing.expectEqual(null, read);
    }

    {
        var iter = HeaderIterator{ .buffer = "\n" };

        var key: []const u8 = undefined;
        var val: []const u8 = undefined;
        const read = try iter.iterate(&key, &val);

        try std.testing.expectEqual(null, read);
    }

    {
        var iter = HeaderIterator{ .buffer = "\n\n\n" };

        var key: []const u8 = undefined;
        var val: []const u8 = undefined;
        const read = try iter.iterate(&key, &val);

        try std.testing.expectEqual(null, read);
    }
}

test "(HeaderIterator).iterate should return error for empty key" {
    // Only zero-length slice: the official Node.js API parses space-only headers...
    var iter = HeaderIterator{ .buffer = ": Value" };

    var key: []const u8 = undefined;
    var val: []const u8 = undefined;
    try std.testing.expectError(
        HeaderIterator.IterateError.EmptyHeaderKey,
        iter.iterate(&key, &val),
    );
}

test "(HeaderIterator).iterate should trim starting spaces" {
    // Many spaces
    {
        var iter = HeaderIterator{ .buffer = "Foo:            Bar" };

        var foo: []const u8 = undefined;
        var bar: []const u8 = undefined;
        const read = try iter.iterate(&foo, &bar);

        try std.testing.expectEqual(19, read);
        try std.testing.expectEqualStrings("Foo", foo);
        try std.testing.expectEqualStrings("Bar", bar);
    }

    // Zero space
    {
        var iter = HeaderIterator{ .buffer = "Foo:Bar" };

        var foo: []const u8 = undefined;
        var bar: []const u8 = undefined;
        const read = try iter.iterate(&foo, &bar);

        try std.testing.expectEqual(7, read);
        try std.testing.expectEqualStrings("Foo", foo);
        try std.testing.expectEqualStrings("Bar", bar);
    }

    // Tab is not a space
    {
        var iter = HeaderIterator{ .buffer = "Foo:\tBar" };

        var foo: []const u8 = undefined;
        var bar: []const u8 = undefined;
        const read = try iter.iterate(&foo, &bar);

        try std.testing.expectEqual(8, read);
        try std.testing.expectEqualStrings("Foo", foo);
        try std.testing.expectEqualStrings("\tBar", bar);
    }

    // Newline is not a space
    {
        var iter = HeaderIterator{ .buffer = "Foo:\nBar" };

        var foo: []const u8 = undefined;
        var bar: []const u8 = undefined;
        const read = try iter.iterate(&foo, &bar);

        try std.testing.expectEqual(5, read);
        try std.testing.expectEqualStrings("Foo", foo);
        try std.testing.expectEqualStrings("", bar);
    }

    // NULL character is not a space
    {
        var iter = HeaderIterator{ .buffer = "Foo:\x00Bar" };

        var foo: []const u8 = undefined;
        var bar: []const u8 = undefined;
        const read = try iter.iterate(&foo, &bar);

        try std.testing.expectEqual(8, read);
        try std.testing.expectEqualStrings("Foo", foo);
        try std.testing.expectEqualStrings("\x00Bar", bar);
    }
}

const BodyParsingContext = struct {
    start_position: usize,

    content_type: []const u8,
    content_length: usize,
};

/// WellKnownHeaders stores headers defined in the official node-roon api source code and
/// discards every other header fields.
pub const WellKnownHeaders = struct {
    /// MIME type.
    /// This slice refers to the source message bytes. Accessing this field after
    /// free-ing the source message bytes is use-after-free.
    content_type: []const u8,

    /// Byte size of the body.
    content_length: usize,

    /// An ID unique to a connection, to associate corresponding request and response.
    request_id: i64,

    body_start_position: usize,

    pub const ParseError = error{
        EmptyContentType,
        NonUintContentLength,
        NonIntRequestID,
        MissingContentType,
        MissingContentLength,
        MissingRequestID,
    } || HeaderIterator.IterateError;

    pub fn parse(message: []const u8, context: HeaderParsingContext) ParseError!@This() {
        var iter = HeaderIterator{ .buffer = message[context.start_position..] };

        var content_type: ?[]const u8 = null;
        var content_length: ?usize = null;
        var request_id: ?i64 = null;

        var i = context.start_position;

        var key: []const u8 = undefined;
        var val: []const u8 = undefined;
        while (try iter.iterate(&key, &val)) |read| {
            i += read;

            // Unlike HTTP headers, MOO headers are case-sensitive.
            if (std.mem.eql(u8, "Content-Type", key)) {
                if (val.len == 0) {
                    return ParseError.EmptyContentType;
                }

                content_type = val;
                continue;
            }

            if (std.mem.eql(u8, "Content-Length", key)) {
                content_length = std.fmt.parseInt(usize, val, 10) catch return ParseError.NonUintContentLength;
                continue;
            }

            if (std.mem.eql(u8, "Request-Id", key)) {
                request_id = std.fmt.parseInt(i64, val, 10) catch return ParseError.NonIntRequestID;
                continue;
            }
        }

        return WellKnownHeaders{
            .content_type = content_type orelse return ParseError.MissingContentType,
            .content_length = content_length orelse return ParseError.MissingContentLength,
            .request_id = request_id orelse return ParseError.MissingRequestID,
            // `i` does not include a final newline.
            .body_start_position = i + 1,
        };
    }

    pub fn getContext(self: *const @This()) BodyParsingContext {
        return .{
            .start_position = self.body_start_position,
            .content_type = self.content_type,
            .content_length = self.content_length,
        };
    }
};

test "WellKnownHeaders.parse should parse well-known headers" {
    const message = "MOO/1 REQUEST foo\nContent-Type: application/json; charset=utf-8\nContent-Length: 876\nRequest-Id: 1\n\n";
    const meta = try Metadata.parse(message);
    const header = try WellKnownHeaders.parse(message, meta.context);

    try std.testing.expectEqualStrings("application/json; charset=utf-8", header.content_type);
    try std.testing.expectEqual(876, header.content_length);
    try std.testing.expectEqual(1, header.request_id);

    const ctx = header.getContext();
    try std.testing.expectEqual(message.len, ctx.start_position);
}

test "WellKnownHeaders.parse should return error when required header is missing" {
    {
        const message = "MOO/1 REQUEST foo\nContent-Length: 876\nRequest-Id: 1\n";
        const meta = try Metadata.parse(message);
        try std.testing.expectError(
            WellKnownHeaders.ParseError.MissingContentType,
            WellKnownHeaders.parse(message, meta.context),
        );
    }

    {
        const message = "MOO/1 REQUEST foo\nContent-Type: application/json; charset=utf-8\nRequest-Id: 1\n";
        const meta = try Metadata.parse(message);
        try std.testing.expectError(
            WellKnownHeaders.ParseError.MissingContentLength,
            WellKnownHeaders.parse(message, meta.context),
        );
    }

    {
        const message = "MOO/1 REQUEST foo\nContent-Type: application/json; charset=utf-8\nContent-Length: 876\n";
        const meta = try Metadata.parse(message);
        try std.testing.expectError(
            WellKnownHeaders.ParseError.MissingRequestID,
            WellKnownHeaders.parse(message, meta.context),
        );
    }
}

test "WellKnownHeaders.parse should return error on an unexpected format" {
    {
        const message = "MOO/1 REQUEST foo\nContent-Type:\nContent-Length: 1\nRequest-Id: 1\n";
        const meta = try Metadata.parse(message);
        try std.testing.expectError(
            WellKnownHeaders.ParseError.EmptyContentType,
            WellKnownHeaders.parse(message, meta.context),
        );
    }

    {
        const message = "MOO/1 REQUEST foo\nContent-Type: text/plain\nContent-Length: 0x87\nRequest-Id: 1\n";
        const meta = try Metadata.parse(message);
        try std.testing.expectError(
            WellKnownHeaders.ParseError.NonUintContentLength,
            WellKnownHeaders.parse(message, meta.context),
        );
    }

    {
        const message = "MOO/1 REQUEST foo\nContent-Type: text/plain\nContent-Length: one\nRequest-Id: 1\n";
        const meta = try Metadata.parse(message);
        try std.testing.expectError(
            WellKnownHeaders.ParseError.NonUintContentLength,
            WellKnownHeaders.parse(message, meta.context),
        );
    }

    {
        const message = "MOO/1 REQUEST foo\nContent-Type: text/plain\nContent-Length: 1\nRequest-Id: 0D8C-F91C-22BB\n";
        const meta = try Metadata.parse(message);
        try std.testing.expectError(
            WellKnownHeaders.ParseError.NonIntRequestID,
            WellKnownHeaders.parse(message, meta.context),
        );
    }
}

/// HashMapHeaders
pub const HashMapHeaders = struct {
    /// Header key-values.
    /// Both key and value points to the source message bytes. Accessing those after
    /// free-ing the source message bytes is use-after-free.
    map: std.hash_map.StringHashMap([]const u8),

    context: BodyParsingContext,

    pub const ParseError = error{
        MissingContentType,
        MissingContentLength,
        EmptyContentType,
        NonUintContentLength,
    } || HeaderIterator.IterateError || std.mem.Allocator.Error;

    pub fn parse(allocator: std.mem.Allocator, message: []const u8, context: HeaderParsingContext) ParseError!@This() {
        var map = std.hash_map.StringHashMap([]const u8).init(allocator);
        var iter = HeaderIterator{ .buffer = message[context.start_position..] };
        var i = context.start_position;

        var content_type: ?[]const u8 = null;
        var content_length: ?usize = null;

        var key: []const u8 = undefined;
        var val: []const u8 = undefined;
        while (try iter.iterate(&key, &val)) |read| {
            i += read;

            if (std.mem.eql(u8, "Content-Type", key)) {
                if (val.len == 0) {
                    return ParseError.EmptyContentType;
                }

                content_type = val;
            } else if (std.mem.eql(u8, "Content-Length", key)) {
                content_length = std.fmt.parseInt(usize, val, 10) catch return ParseError.NonUintContentLength;
            }

            try map.put(key, val);
        }

        return HashMapHeaders{
            .map = map,
            .context = .{
                .content_type = content_type orelse return ParseError.MissingContentType,
                .content_length = content_length orelse return ParseError.MissingContentLength,
                // `i` does not include a final newline.
                .start_position = i + 1,
            },
        };
    }

    pub fn deinit(self: *@This()) void {
        self.map.deinit();
    }
};

test "HashMapHeaders.parse should save every headers" {
    const message = "MOO/1 REQUEST foo\nContent-Type: application/json; charset=utf-8\nContent-Length: 876\nRequest-Id: 1\nFoo: Bar\n\n";
    const meta = try Metadata.parse(message);
    var header = try HashMapHeaders.parse(std.testing.allocator, message, meta.context);
    defer header.deinit();

    try std.testing.expectEqualStrings(header.map.get("Content-Type").?, "application/json; charset=utf-8");
    try std.testing.expectEqualStrings(header.map.get("Content-Length").?, "876");
    try std.testing.expectEqualStrings(header.map.get("Request-Id").?, "1");
    try std.testing.expectEqualStrings(header.map.get("Foo").?, "Bar");
    try std.testing.expectEqual(message.len, header.context.start_position);
}

/// RawBody contains a bytes slice of body section in a MOO message.
/// The bytes field points to the source message bytes: freeing the source message bytes
/// then accessing the bytes field results in use-after-free.
pub const RawBody = struct {
    bytes: []const u8,

    pub const ParseError = error{
        ContentLengthMismatch,
    };

    pub fn parse(message: []const u8, context: BodyParsingContext) ParseError!@This() {
        const start = @min(context.start_position, message.len);
        const bytes = message[start..];

        if (bytes.len != context.content_length) {
            return ParseError.ContentLengthMismatch;
        }

        return .{ .bytes = bytes };
    }
};

test "RawBody.parse should save rest of the bytes" {
    const message = "MOO/1 REQUEST foo\nContent-Type: text/plain\nContent-Length: 13\nRequest-Id: 1\n\nHello, World!";
    const meta = try Metadata.parse(message);
    const header = try WellKnownHeaders.parse(message, meta.context);
    const body = try RawBody.parse(message, header.getContext());

    try std.testing.expectEqualStrings("Hello, World!", body.bytes);
}

test "RawBody.parse should reject mismatching Content-Length" {
    {
        const message = "MOO/1 REQUEST foo\nContent-Type: text/plain\nContent-Length: 12\nRequest-Id: 1\n\nHello, World!";
        const meta = try Metadata.parse(message);
        const header = try WellKnownHeaders.parse(message, meta.context);
        const err = RawBody.parse(message, header.getContext());

        try std.testing.expectError(RawBody.ParseError.ContentLengthMismatch, err);
    }

    {
        const message = "MOO/1 REQUEST foo\nContent-Type: text/plain\nContent-Length: 14\nRequest-Id: 1\n\nHello, World!";
        const meta = try Metadata.parse(message);
        const header = try WellKnownHeaders.parse(message, meta.context);
        const err = RawBody.parse(message, header.getContext());

        try std.testing.expectError(RawBody.ParseError.ContentLengthMismatch, err);
    }
}

/// JsonBody stores MOO message body as JSON value. User has to provided an expected
/// type (schema) as "T".
pub fn JsonBody(comptime T: type) type {
    return struct {
        allocator: std.mem.Allocator,
        value: *const T,
        parsed: std.json.Parsed(T),

        pub const ParseError = error{
            ContentLengthMismatch,
            ContentTypeIsNotApplicationJson,
        } || std.json.ParseError(std.json.Scanner);

        pub fn parse(allocator: std.mem.Allocator, message: []const u8, context: BodyParsingContext) ParseError!@This() {
            // Same MIME checking as one in the official Node.js API.
            // This does not match to "application/json; charset=utf-8" or such.
            // (not doing the strict MIME check because parsing MIME is complex task)
            if (!std.mem.eql(u8, "application/json", context.content_type)) {
                return ParseError.ContentTypeIsNotApplicationJson;
            }

            const start = @min(context.start_position, message.len);
            const bytes = message[start..];

            if (bytes.len != context.content_length) {
                return ParseError.ContentLengthMismatch;
            }

            const parsed = try std.json.parseFromSlice(T, allocator, bytes, .{});

            return .{
                .allocator = allocator,
                .value = &parsed.value,
                .parsed = parsed,
            };
        }

        pub fn deinit(self: *const @This()) void {
            self.parsed.deinit();
        }
    };
}

test "JsonBody.parse should deserialize body as JSON" {
    const payload = "{\"foo\": 8}";

    var message_buffer = std.ArrayList(u8).init(std.testing.allocator);
    defer message_buffer.deinit();

    try std.fmt.format(
        message_buffer.writer(),
        "MOO/1 REQUEST foo\nContent-Type: application/json\nContent-Length: {d}\nRequest-Id: 1\n\n{s}",
        .{ payload.len, payload },
    );

    const message = try message_buffer.toOwnedSlice();
    defer std.testing.allocator.free(message);

    const TestData = struct {
        foo: i32,
    };

    const meta = try Metadata.parse(message);
    const header = try WellKnownHeaders.parse(message, meta.context);
    const body = try JsonBody(TestData).parse(std.testing.allocator, message, header.getContext());
    defer body.deinit();

    try std.testing.expectEqual(body.value.foo, 8);
}

test "JsonBody.parse should reject invalid JSON text" {
    const payload = "{\"foo\": 0x8}";

    var message_buffer = std.ArrayList(u8).init(std.testing.allocator);
    defer message_buffer.deinit();

    try std.fmt.format(
        message_buffer.writer(),
        "MOO/1 REQUEST foo\nContent-Type: application/json\nContent-Length: {d}\nRequest-Id: 1\n\n{s}",
        .{ payload.len, payload },
    );

    const message = try message_buffer.toOwnedSlice();
    defer std.testing.allocator.free(message);

    const TestData = struct {
        foo: i32,
    };

    const meta = try Metadata.parse(message);
    const header = try WellKnownHeaders.parse(message, meta.context);
    const err = JsonBody(TestData).parse(std.testing.allocator, message, header.getContext());

    try std.testing.expectError(JsonBody(TestData).ParseError.SyntaxError, err);
}

test "JsonBody.parse should reject mismatching Content-Length" {
    const payload = "{\"foo\": 8}";

    var message_buffer = std.ArrayList(u8).init(std.testing.allocator);
    defer message_buffer.deinit();

    try std.fmt.format(
        message_buffer.writer(),
        "MOO/1 REQUEST foo\nContent-Type: application/json\nContent-Length: {d}\nRequest-Id: 1\n\n{s}",
        .{ payload.len + 1, payload },
    );

    const message = try message_buffer.toOwnedSlice();
    defer std.testing.allocator.free(message);

    const TestData = struct {
        foo: i32,
    };

    const meta = try Metadata.parse(message);
    const header = try WellKnownHeaders.parse(message, meta.context);
    const err = JsonBody(TestData).parse(std.testing.allocator, message, header.getContext());

    try std.testing.expectError(JsonBody(TestData).ParseError.ContentLengthMismatch, err);
}

test "JsonBody.parse should reject Content-Type other than application/json" {
    const payload = "{\"foo\": 8}";

    var message_buffer = std.ArrayList(u8).init(std.testing.allocator);
    defer message_buffer.deinit();

    try std.fmt.format(
        message_buffer.writer(),
        "MOO/1 REQUEST foo\nContent-Type: text/json\nContent-Length: {d}\nRequest-Id: 1\n\n{s}",
        .{ payload.len, payload },
    );

    const message = try message_buffer.toOwnedSlice();
    defer std.testing.allocator.free(message);

    const TestData = struct {
        foo: i32,
    };

    const meta = try Metadata.parse(message);
    const header = try WellKnownHeaders.parse(message, meta.context);
    const err = JsonBody(TestData).parse(std.testing.allocator, message, header.getContext());

    try std.testing.expectError(JsonBody(TestData).ParseError.ContentTypeIsNotApplicationJson, err);
}