1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98

// 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);
        errdefer 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 });
    }
};