/core/src/services/BrowseService.zig at 87a170f9d28ccdb128ca0552977163174cec30ee

// 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 id = "com.roonlabs.browse:1";

pub const Item = struct {
    title: []const u8,
    subtitle: ?[]const u8 = null,
    image_key: ?[]const u8 = null,
    item_key: ?[]const u8 = null,
    hint: Hint = .unknown,
    input_prompt: ?InputPrompt = null,

    pub const Hint = enum {
        unknown,
        action,
        action_list,
        list,
        header,

        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, "unknown")) {
                            continue;
                        }

                        if (std.mem.eql(u8, field.name, v)) {
                            return @enumFromInt(field.value);
                        }
                    }

                    return .unknown;
                },
                else => .unknown,
            };
        }
    };

    pub const InputPrompt = struct {
        prompt: []const u8,
        action: []const u8,
        value: ?[]const u8 = null,
        is_password: bool = false,
    };
};

pub const List = struct {
    title: []const u8,
    count: usize = 0,
    subtitle: ?[]const u8 = null,
    image_key: ?[]const u8 = null,
    level: usize = 0,
    display_offset: ?i64 = null,
    hint: Hint = .unknown,

    pub const Hint = enum {
        unknown,
        action_list,

        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, "unknown")) {
                            continue;
                        }

                        if (std.mem.eql(u8, field.name, v)) {
                            return @enumFromInt(field.value);
                        }
                    }

                    return .unknown;
                },
                else => .unknown,
            };
        }
    };
};

pub const Browse = struct {
    const method = "/browse";

    pub const Request = struct {
        hierarchy: []const u8,
        item_key: ?[]const u8 = null,
        input: ?[]const u8 = null,
        zone_or_output_id: ?[]const u8 = null,
        pop_all: ?bool = null,
        pop_levels: ?usize = null,
        refresh_list: ?bool = null,

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

            const body = moo.JsonBody(Request).init(&self, .{
                .emit_null_optional_fields = false,
            });

            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 Response = struct {
        action: Action,
        item: ?Item = null,
        list: ?List = null,
        message: ?[]const u8 = null,
        is_error: ?bool = null,

        const Action = enum {
            message,
            none,
            list,
            replace_item,
            remove_item,
        };

        pub const Error = error{
            NonSuccessResponse,
        };

        pub fn parse(
            allocator: std.mem.Allocator,
            meta: *const moo.Metadata,
            header_ctx: moo.HeaderParsingContext,
            message: []const u8,
        ) !moo.JsonBody(Response) {
            if (!std.mem.eql(u8, meta.service, "Success")) {
                std.log.err("Expected \"Success\" for {s} endpoint, got \"{s}\"", .{ method, meta.service });
                return Error.NonSuccessResponse;
            }

            _, 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 Load = struct {
    const method = "/load";

    pub const Request = struct {
        set_display_offset: ?i64 = null,
        level: ?usize = 0,
        offset: ?i64 = 0,
        count: ?usize = 0,
        hierarchy: []const u8,
        multi_session_key: ?[]const u8 = null,

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

            const body = moo.JsonBody(Request).init(&self, .{
                .emit_null_optional_fields = false,
            });

            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 Response = struct {
        items: []const Item,
        offset: i64 = 0,
        list: List,

        pub const Error = error{
            NonSuccessResponse,
        };

        pub fn parse(
            allocator: std.mem.Allocator,
            meta: *const moo.Metadata,
            header_ctx: moo.HeaderParsingContext,
            message: []const u8,
        ) !moo.JsonBody(Response) {
            if (!std.mem.eql(u8, meta.service, "Success")) {
                std.log.err("Expected \"Success\" for {s} endpoint, got \"{s}\"", .{ method, meta.service });
                return Error.NonSuccessResponse;
            }

            _, 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,
            });
        }
    };
};