/old_core/src/roon/services/transport.zig at 047caaf8b72945f5e9ca2f7756dd18cc31bc83dd

// 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");

const Connection = @import("../connection.zig").Connection;

/// Use of this service requires registration.
pub const TransportService = struct {
    pub const id = "com.roonlabs.transport:2";

    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,
        state: PlaybackState,
    };

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

    pub const GetZonesError = error{
        NonSuccessResponse,
    };

    pub fn getZones(allocator: std.mem.Allocator, conn: *Connection) !moo.JsonBody(GetZonesResponse) {
        const request_id = conn.newRequestId();

        const meta = moo.Metadata{
            .service = id ++ "/get_zones",
            .verb = "REQUEST",
        };

        const body = moo.NoBody{};
        const headers = body.getHeader(request_id);

        const request = try allocator.alloc(u8, meta.getEncodeSize() + headers.getEncodeSize() + body.getEncodeSize());
        defer allocator.free(request);

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

        const message = try conn.request(request_id, request);
        defer conn.allocator.free(message);

        const meta_res, const header_ctx = try moo.Metadata.parse(message);
        if (!std.mem.eql(u8, meta_res.service, "Success")) {
            std.log.warn("Expected \"Success\" for {s}/get_zones endpoint, got \"{s}\"\n", .{ id, meta_res.service });
            return GetZonesError.NonSuccessResponse;
        }

        const headers_res, const body_ctx = try moo.WellKnownHeaders.parse(message, header_ctx);
        std.log.debug("Got successful response on {s}/get_zones (request_id={d})", .{ id, headers_res.request_id });

        return try moo.JsonBody(GetZonesResponse).parse(allocator, message, body_ctx, .{
            .ignore_unknown_fields = true,
            .allocate = .alloc_always,
        });
    }

    const SubscribeZoneChangesSubscribedResponse = struct {
        zones: []const Zone = &.{},
    };

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

    pub const ZoneChangeSubscription = struct {
        subscription: Connection.Subscription,

        const Data = struct {
            allocator: std.mem.Allocator,
            added_zones: []const Zone,
            changed_zones: []const Zone,
            removed_ids: []const []const u8,
            original_message: union(enum) {
                subscribed: moo.JsonBody(SubscribeZoneChangesSubscribedResponse),
                changed: moo.JsonBody(SubscribeZoneChangesChangedResponse),
            },
            message_bytes: []const u8,

            pub fn deinit(self: *const Data) void {
                switch (self.original_message) {
                    .subscribed => |msg| msg.deinit(),
                    .changed => |msg| msg.deinit(),
                }
                self.allocator.free(self.message_bytes);
            }
        };

        const Iterator = struct {
            parent: *ZoneChangeSubscription,

            pub const Error = error{
                UnknownService,
                UnsubscribedByServer,
            };

            /// Returns the next zone change event. This function blocks until next event.
            /// Caller must call `.deinit()` after using the returned struct.
            pub fn next(self: *Iterator, allocator: std.mem.Allocator) !?Data {
                const message = try self.parent.subscription.next(allocator) orelse return null;
                errdefer allocator.free(message);

                const meta, const header_ctx = try moo.Metadata.parse(message);
                if (std.mem.eql(u8, meta.service, "Unsubscribed")) {
                    return Error.UnsubscribedByServer;
                }

                if (std.mem.eql(u8, meta.service, "Subscribed")) {
                    _, const body_ctx = try moo.WellKnownHeaders.parse(message, header_ctx);
                    const body = try moo.JsonBody(SubscribeZoneChangesSubscribedResponse).parse(
                        allocator,
                        message,
                        body_ctx,
                        .{
                            .ignore_unknown_fields = true,
                        },
                    );

                    return Data{
                        .allocator = allocator,
                        .added_zones = body.value.zones,
                        .changed_zones = &.{},
                        .removed_ids = &.{},
                        .original_message = .{
                            .subscribed = body,
                        },
                        .message_bytes = message,
                    };
                }

                if (std.mem.eql(u8, meta.service, "Changed")) {
                    _, const body_ctx = try moo.WellKnownHeaders.parse(message, header_ctx);
                    const body = try moo.JsonBody(SubscribeZoneChangesChangedResponse).parse(
                        allocator,
                        message,
                        body_ctx,
                        .{
                            .ignore_unknown_fields = true,
                        },
                    );

                    return Data{
                        .allocator = allocator,
                        .added_zones = body.value.zones_added,
                        .changed_zones = body.value.zones_changed,
                        .removed_ids = body.value.zones_removed,
                        .original_message = .{
                            .changed = body,
                        },
                        .message_bytes = message,
                    };
                }

                return Error.UnknownService;
            }
        };

        pub fn init(conn: *Connection) ZoneChangeSubscription {
            return .{
                .subscription = conn.subscribe(id, "zones"),
            };
        }

        /// Call to this function after the call to `Connection.deinit()` is useless and invalid.
        pub fn deinit(self: *ZoneChangeSubscription) void {
            self.subscription.deinit();
        }

        pub fn iter(self: *ZoneChangeSubscription, allocator: std.mem.Allocator) !Iterator {
            try self.subscription.activate(allocator);

            return .{ .parent = self };
        }
    };
};