/core/src/image.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 Arc = @import("./Arc.zig");
const Server = @import("./discovery.zig").Server;
const freelog = @import("./log.zig").freelog;
const ImageService = @import("./services/ImageService.zig");

pub const ScalingMethod = enum(c_int) {
    fit = 0,
    fill = 1,
    stretch = 2,
};

pub const ContentType = enum(c_int) {
    jpeg = 0,
    png = 1,
};

pub const GetResultCode = enum(c_int) {
    ok = 0,
    unknown_error = 1,
    out_of_memory = 2,
    unexpected_response = 3,
    socket_closed = 4,
    failed_to_send = 5,
    timeout = 6,
};

pub const GetOptions = extern struct {
    const cname = "plac_image_get_options";
    const allocator = std.heap.c_allocator;

    internal: *Internal,

    const Internal = struct {
        arc: Arc = .{},
        data: Data = .{},

        const Data = struct {
            size: ?Size = null,
            content_type: ?ContentType = null,

            const Size = struct {
                scaling_method: ScalingMethod,
                width: usize,
                height: usize,
            };
        };
    };

    pub fn makeRetained() callconv(.C) ?*@This() {
        const internal = allocator.create(Internal) catch {
            return null;
        };
        internal.* = .{};

        const self = allocator.create(@This()) catch {
            allocator.destroy(internal);
            return null;
        };
        self.* = .{ .internal = internal };

        return self.retain();
    }

    pub fn retain(ptr: ?*@This()) callconv(.C) *@This() {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        self.internal.arc.ref();
        return self;
    }

    pub fn release(ptr: ?*@This()) callconv(.C) void {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        if (self.internal.arc.unref()) {
            freelog(self);

            allocator.destroy(self.internal);
            allocator.destroy(self);
        }
    }

    pub fn setSize(
        ptr: ?*@This(),
        scaling: ScalingMethod,
        width: usize,
        height: usize,
    ) callconv(.C) void {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        _ = self.retain();
        defer self.release();

        self.internal.data.size = .{
            .scaling_method = scaling,
            .width = width,
            .height = height,
        };
    }

    pub fn setContentType(ptr: ?*@This(), content_type: ContentType) callconv(.C) void {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        _ = self.retain();
        defer self.release();

        self.internal.data.content_type = content_type;
    }

    pub fn export_capi() void {
        @export(&makeRetained, .{ .name = std.fmt.comptimePrint("{s}_make", .{cname}) });
        @export(&retain, .{ .name = std.fmt.comptimePrint("{s}_retain", .{cname}) });
        @export(&release, .{ .name = std.fmt.comptimePrint("{s}_release", .{cname}) });
        @export(&setSize, .{ .name = std.fmt.comptimePrint("{s}_set_size", .{cname}) });
        @export(&setContentType, .{ .name = std.fmt.comptimePrint("{s}_set_content_type", .{cname}) });
    }
};

pub const Image = extern struct {
    const cname = "plac_image_image";
    const allocator = std.heap.c_allocator;

    internal: *Internal,
    content_type: ContentType,
    data_ptr: [*]const u8,
    data_len: usize,

    const Internal = struct {
        arc: Arc = .{},
    };

    pub fn make(src: *const ImageService.Get.Response) std.mem.Allocator.Error!*@This() {
        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        internal.* = .{};

        const data = try allocator.dupe(u8, src.data);
        errdefer allocator.free(data);

        const self = try allocator.create(@This());
        errdefer allocator.destroy(self);

        self.* = .{
            .internal = internal,
            .content_type = switch (src.content_type) {
                .jpeg => ContentType.jpeg,
                .png => ContentType.png,
            },
            .data_ptr = data.ptr,
            .data_len = data.len,
        };

        return self;
    }

    pub fn retain(ptr: ?*@This()) callconv(.C) *@This() {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        self.internal.arc.ref();
        return self;
    }

    pub fn release(ptr: ?*@This()) callconv(.C) void {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        if (self.internal.arc.unref()) {
            freelog(self);

            allocator.free(self.data_ptr[0..self.data_len]);
            allocator.destroy(self.internal);
            allocator.destroy(self);
        }
    }

    pub fn export_capi() void {
        @export(&retain, .{ .name = std.fmt.comptimePrint("{s}_retain", .{cname}) });
        @export(&release, .{ .name = std.fmt.comptimePrint("{s}_release", .{cname}) });
    }
};

pub const GetResult = extern struct {
    const cname = "plac_image_get_result";
    const allocator = std.heap.c_allocator;

    internal: *Internal,
    code: GetResultCode = .ok,
    image: ?*Image = null,

    const Internal = struct {
        arc: Arc = .{},
    };

    pub fn make(src: *const ImageService.Get.Response) std.mem.Allocator.Error!*@This() {
        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        internal.* = .{};

        const self = try allocator.create(@This());
        errdefer allocator.destroy(self);

        const image = try Image.make(src);
        _ = image.retain();

        self.* = .{
            .internal = internal,
            .image = image,
        };

        return self;
    }

    pub inline fn makeRetained(src: *const ImageService.Get.Response) std.mem.Allocator.Error!*@This() {
        const result = try make(src);
        return result.retain();
    }

    pub fn makeError(code: GetResultCode) std.mem.Allocator.Error!*@This() {
        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        internal.* = .{};

        const self = try allocator.create(@This());
        errdefer allocator.destroy(self);

        self.* = .{
            .internal = internal,
            .code = code,
        };

        return self;
    }

    pub inline fn makeRetainedError(code: GetResultCode) std.mem.Allocator.Error!*@This() {
        const result = try makeError(code);
        return result.retain();
    }

    pub fn retain(ptr: ?*@This()) callconv(.C) *@This() {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        self.internal.arc.ref();
        return self;
    }

    pub fn release(ptr: ?*@This()) callconv(.C) void {
        var self = ptr orelse @panic(
            std.fmt.comptimePrint("Received null pointer on {s}_{s}", .{ cname, @src().fn_name }),
        );
        if (self.internal.arc.unref()) {
            freelog(self);

            if (self.image) |image| {
                image.release();
            }
            allocator.destroy(self.internal);
            allocator.destroy(self);
        }
    }

    pub fn export_capi() void {
        @export(&retain, .{ .name = std.fmt.comptimePrint("{s}_retain", .{cname}) });
        @export(&release, .{ .name = std.fmt.comptimePrint("{s}_release", .{cname}) });
    }
};

pub fn export_capi() void {
    Image.export_capi();
    GetOptions.export_capi();
    GetResult.export_capi();
}

pub fn Downloader(concurrent_download_limit: u5) type {
    return struct {
        const Job = struct {
            ready: std.Thread.ResetEvent = .{},
            result: *GetResult = undefined,
            req_hash: u64,
        };

        // a bit is set (1) = available, otherwise occupied.
        // ex) truncating size to u8, concurrent download limit = 5
        //     0b00011111 = Fully available
        //     0b00011110 = First item is occupied, second item is available
        //     0b00000000 = Fully occupied
        downloads: u32 = ~(@as(u32, std.math.maxInt(u32)) << concurrent_download_limit),
        mutex: std.Thread.Mutex = .{},
        cond: std.Thread.Condition = .{},
        downloads_queue: std.DoublyLinkedList(Job) = .{},
        http_client: std.http.Client,
        is_closed: bool = false,

        pub fn init(allocator: std.mem.Allocator) @This() {
            return .{
                .http_client = std.http.Client{
                    .allocator = allocator,
                },
            };
        }

        pub fn deinit(self: *@This()) void {
            self.is_closed = true;
            self.mutex.lock();
            self.downloads = std.math.maxInt(u32);
            self.cond.signal();
            self.mutex.unlock();

            self.http_client.deinit();
        }

        fn hash(url: []const u8) u64 {
            var hasher = std.hash.Wyhash.init(0);
            std.hash.autoHashStrat(&hasher, url, .Deep);
            return hasher.final();
        }

        pub fn download(
            self: *@This(),
            allocator: std.mem.Allocator,
            req: *const ImageService.Get.Request,
            server: *Server,
        ) std.mem.Allocator.Error!*GetResult {
            _ = server.retain();
            defer server.release();

            const format = req.format orelse {
                std.log.err("Downloading image without specifying format is not currently supported", .{});
                return try GetResult.makeRetainedError(.failed_to_send);
            };

            const url = req.url(allocator, server.internal.address) catch |err| {
                std.log.err("Unable to construct image download URL: {s}", .{@errorName(err)});
                return try GetResult.makeRetainedError(.unknown_error);
            };
            defer allocator.free(url);

            const req_hash = hash(url);

            {
                var node = self.downloads_queue.first;
                while (node) |d| : (node = d.next) {
                    if (d.data.req_hash == req_hash) {
                        d.data.ready.wait();
                        return d.data.result.retain();
                    }
                }
            }

            var node: std.DoublyLinkedList(Job).Node = .{
                .data = .{
                    .req_hash = req_hash,
                },
            };

            self.downloads_queue.prepend(&node);
            defer self.downloads_queue.remove(&node);

            const job_index: u5 = job_index: {
                self.mutex.lock();
                defer self.mutex.unlock();

                while (self.downloads == 0) {
                    self.cond.wait(&self.mutex);
                }

                if (self.is_closed) {
                    return try GetResult.makeRetainedError(.socket_closed);
                }

                const i = @min(@ctz(self.downloads), std.math.maxInt(u5));
                self.downloads &= ~(@as(u32, 1) << i);

                break :job_index i;
            };

            std.log.debug("Downloading image({d}) {s}", .{ job_index, url });

            defer {
                self.mutex.lock();
                defer self.mutex.unlock();

                if (!self.is_closed) {
                    self.downloads |= @as(u32, 1) << job_index;
                    self.cond.signal();
                }
            }

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

            const result = self.http_client.fetch(.{
                .location = .{ .url = url },
                .method = .GET,
                .redirect_behavior = .not_allowed,
                .headers = .{
                    .content_type = .{
                        .override = if (format == .jpeg) "image/jpeg" else "image/png",
                    },
                },
                .response_storage = .{ .dynamic = &response },
            }) catch |err| {
                if (err == error.ConnectionTimedOut) {
                    std.log.err("Image download timed out", .{});
                    return try GetResult.makeRetainedError(.timeout);
                }

                std.log.err("Failed to download image: {s}", .{@errorName(err)});
                return try GetResult.makeRetainedError(.unknown_error);
            };

            if (result.status != .ok) {
                std.log.err("Unexpected image download response: HTTP({d}) {s}", .{
                    @intFromEnum(result.status),
                    @tagName(result.status),
                });
                return try GetResult.makeRetainedError(.unexpected_response);
            }

            const moo_resp = ImageService.Get.Response{
                // TODO: Set from parsed HTTP response header
                .content_type = format,
                .data = response.items,
            };

            const get_result = try GetResult.make(&moo_resp);
            node.data.result = get_result;
            node.data.ready.set();

            return get_result.retain();
        }
    };
}