/core/src/services/transport.zig at 915553e7e67366b455125dedd20c696f05badef5

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

const std = @import("std");

const moo = @import("moo");

pub const TransportService = struct {
    pub const id = "com.roonlabs.transport:2";

    pub const NowPlaying = struct {
        one_line: struct {
            line1: []const u8,
        },
        two_line: struct {
            line1: []const u8,
            line2: ?[]const u8 = null,
        },
        three_line: struct {
            line1: []const u8,
            line2: ?[]const u8 = null,
            line3: ?[]const u8 = null,
        },
    };

    pub const PlaybackState = enum {
        playing,
        paused,
        loading,
        stopped,

        pub fn jsonParseFromValue(
            _: std.mem.Allocator,
            value: std.json.Value,
            _: std.json.ParseOptions,
        ) std.json.ParseFromValueError!@This() {
            return switch (value) {
                .string => |v| {
                    inline for (@typeInfo(@This()).@"enum".fields) |field| {
                        if (std.mem.eql(u8, field.name, v)) {
                            return @enumFromInt(field.value);
                        }
                    }

                    return std.json.ParseFromValueError.InvalidEnumTag;
                },
                else => std.json.ParseFromValueError.UnexpectedToken,
            };
        }
    };

    pub const Zone = struct {
        zone_id: []const u8,
        display_name: []const u8,
        now_playing: ?NowPlaying = null,
        state: PlaybackState,
        is_next_allowed: bool = false,
        is_previous_allowed: bool = false,
        is_pause_allowed: bool = false,
        is_play_allowed: bool = false,
        is_seek_allowed: bool = false,
    };

    pub const SubscribeZoneChanges = struct {
        pub const Request = struct {
            subscription_key: []const u8,
        };

        pub fn request(allocator: std.mem.Allocator, request_id: i64, subscription_id: u64) ![]u8 {
            const meta = moo.Metadata{
                .service = id ++ "/subscribe_zones",
                .verb = "REQUEST",
            };

            var sub_id_buf: [std.fmt.count("{}", .{std.math.maxInt(u64)})]u8 = undefined;
            var sub_id_fbs = std.io.fixedBufferStream(&sub_id_buf);
            try std.fmt.format(sub_id_fbs.writer(), "{}", .{subscription_id});

            const body = moo.JsonBody(Request).init(&.{
                .subscription_key = sub_id_fbs.getWritten(),
            });
            const header = body.getHeader(request_id);

            const buf = try allocator.alloc(
                u8,
                meta.getEncodeSize() + header.getEncodeSize() + body.getEncodeSize(),
            );
            errdefer allocator.free(buf);

            var fbs = std.io.fixedBufferStream(buf);
            try moo.encode(fbs.writer(), meta, header, body);

            return buf;
        }

        pub const InitialResponse = struct {
            zones: []const Zone,
        };

        pub fn initialResponse(
            allocator: std.mem.Allocator,
            header_ctx: moo.HeaderParsingContext,
            message: []const u8,
        ) !moo.JsonBody(InitialResponse) {
            _, const body_ctx = try moo.WellKnownHeaders.parse(message, header_ctx);
            return try moo.JsonBody(InitialResponse).parse(allocator, message, body_ctx, .{
                .ignore_unknown_fields = true,
                .allocate = .alloc_always,
            });
        }

        pub const Response = struct {
            zones_removed: []const []const u8 = &.{},
            zones_added: []const Zone = &.{},
            zones_changed: []const Zone = &.{},
        };

        pub fn response(
            allocator: std.mem.Allocator,
            header_ctx: moo.HeaderParsingContext,
            message: []const u8,
        ) !moo.JsonBody(Response) {
            _, const body_ctx = try moo.WellKnownHeaders.parse(message, header_ctx);
            return try moo.JsonBody(Response).parse(allocator, message, body_ctx, .{
                .ignore_unknown_fields = true,
                .allocate = .alloc_always,
            });
        }
    };

    pub const Control = enum {
        play,
        pause,
        playpause,
        stop,
        previous,
        next,

        const method = "/control";

        pub const Request = struct {
            zone_or_output_id: []const u8,
            control: []const u8,
        };

        /// Caller owns the returned memory
        pub fn request(
            self: Control,
            allocator: std.mem.Allocator,
            request_id: i64,
            zone_id: []const u8,
        ) ![]u8 {
            const meta = moo.Metadata{
                .service = id ++ method,
                .verb = "REQUEST",
            };

            const body = moo.JsonBody(Request).init(&Request{
                .zone_or_output_id = zone_id,
                .control = @tagName(self),
            });

            const header = body.getHeader(request_id);

            const buf = try allocator.alloc(
                u8,
                meta.getEncodeSize() + header.getEncodeSize() + body.getEncodeSize(),
            );
            errdefer allocator.free(buf);

            var fbs = std.io.fixedBufferStream(buf);
            try moo.encode(fbs.writer(), meta, header, body);

            return buf;
        }

        pub const ResponseError = error{
            NonSuccessResponse,
        };

        pub fn response(
            meta: *const moo.Metadata,
        ) ResponseError!void {
            if (!std.mem.eql(u8, meta.service, "Success")) {
                std.log.err("Expected \"Success\" for {s} endpoint, got \"{s}\"", .{ method, meta.service });
                return ResponseError.NonSuccessResponse;
            }
        }
    };
};