/core/src/services/ImageService.zig at bcf2497d8a5f079ca81cce0e2c48725894e42170

// 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.image:1";

pub const ScalingMethod = enum {
    fit,
    fill,
    stretch,

    pub fn jsonStringify(self: @This(), jws: anytype) !void {
        try jws.write(@tagName(self));
    }
};

pub const ContentType = enum {
    jpeg,
    png,

    pub fn jsonStringify(self: @This(), jws: anytype) !void {
        try jws.write(switch (self) {
            .jpeg => "image/jpeg",
            .png => "image/png",
        });
    }

    pub const FromStringError = error{
        UnknownContentType,
    };

    pub fn fromString(input: []const u8) FromStringError!@This() {
        inline for (@typeInfo(@This()).@"enum".fields) |field| {
            if (std.mem.eql(u8, input, std.fmt.comptimePrint("image/{s}", .{field.name}))) {
                return @enumFromInt(field.value);
            }
        }

        return FromStringError.UnknownContentType;
    }
};

pub const Get = struct {
    const method = "/get_image";

    pub const Request = struct {
        scale: ?ScalingMethod = null,
        width: ?usize = null,
        height: ?usize = null,
        format: ?ContentType = null,
        image_key: []const u8,

        pub fn encode(
            self: @This(),
            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 fn url(self: *const @This(), allocator: std.mem.Allocator, addr: std.net.Address) ![]const u8 {
            const path = try std.fmt.allocPrint(allocator, "/api/image/{s}", .{self.image_key});
            defer allocator.free(path);

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

            const query_writer = query.writer();

            if (self.scale) |scale| {
                try std.fmt.format(query_writer, "&scale={s}", .{@tagName(scale)});
            }

            if (self.width) |width| {
                try std.fmt.format(query_writer, "&width={d}", .{width});
            }

            if (self.height) |height| {
                try std.fmt.format(query_writer, "&height={d}", .{height});
            }

            if (self.format) |format| {
                try std.fmt.format(query_writer, "&format=image/{s}", .{@tagName(format)});
            }

            const query_component: ?std.Uri.Component = if (query.items.len > 0) .{
                .raw = query.items[1..],
            } else null;

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

            try addr.format("", .{}, origin.writer());

            var uri = std.Uri{
                .scheme = "http",
                .host = .{
                    // std.net.Address is POSIX's address, which contains both IP address and port.
                    // The type has no method to print only IP address part.
                    .percent_encoded = origin.items,
                },
                .path = .{
                    .raw = path,
                },
                .query = query_component,
            };

            var result = std.ArrayList(u8).init(allocator);
            errdefer result.deinit();

            try uri.writeToStream(.{
                .scheme = true,
                .authority = true,
                .path = true,
                .query = true,
            }, result.writer());

            return result.toOwnedSlice();
        }

        test url {
            const req = Request{
                .image_key = "foo",
            };

            const result = try req.url(std.testing.allocator, try std.net.Address.parseIp("127.0.0.1", 8080));
            defer std.testing.allocator.free(result);

            try std.testing.expectEqualStrings("http://127.0.0.1:8080/api/image/foo", result);
        }

        test "url constructs search params" {
            const req = Request{
                .image_key = "foo",
                .scale = .fit,
                .width = 100,
                .height = 200,
                .format = .png,
            };

            const result = try req.url(std.testing.allocator, try std.net.Address.parseIp("127.0.0.1", 8080));
            defer std.testing.allocator.free(result);

            try std.testing.expectEqualStrings(
                "http://127.0.0.1:8080/api/image/foo?scale=fit&width=100&height=200&format=image/png",
                result,
            );
        }
    };

    pub const Response = struct {
        content_type: ContentType,
        data: []const u8,

        pub const DecodeError = error{
            NonSuccessResponse,
        };

        /// Returned response's `data` field is a slice of `message` bytes.
        pub fn decode(
            meta: *const moo.Metadata,
            header_ctx: moo.HeaderParsingContext,
            message: []const u8,
        ) !@This() {
            if (!std.mem.eql(u8, meta.service, "Success")) {
                std.log.err(
                    "Expected \"Success\" for {s}{s}, got \"{s}\"",
                    .{ id, method, meta.service },
                );
                return DecodeError.NonSuccessResponse;
            }

            const header, const body_ctx = try moo.WellKnownHeaders.parse(message, header_ctx);
            const content_type = try ContentType.fromString(header.content_type);

            const body = try moo.RawBody.parse(message, body_ctx);

            return .{ .content_type = content_type, .data = body.bytes };
        }
    };
};

test {
    _ = Get.Request.url;
}