/core/src/image.zig at 06b251d3bb7ed7bdb1ef59aa66d74ae5a43489ef

// 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 makeCached(image: *Image) 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,
            .image = image.retain(),
        };

        return self;
    }

    pub inline fn makeCachedRetained(image: *Image) std.mem.Allocator.Error!*@This() {
        const result = try makeCached(image);
        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();
}

fn DoubleFifoCache(comptime T: type, short_size: usize, main_size: usize) type {
    return struct {
        pub const Data = T;

        pub const Entry = struct {
            hash: u64,
            data: *Data,
            accessed: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
        };

        allocator: std.mem.Allocator,
        short: std.DoublyLinkedList(Entry) = .{},
        main: std.DoublyLinkedList(Entry) = .{},

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

        pub fn deinit(self: *@This()) void {
            while (self.short.pop()) |popped| {
                self.release(popped);
            }

            while (self.main.pop()) |popped| {
                self.release(popped);
            }
        }

        pub fn get(self: *@This(), hash: u64) ?*Data {
            var entry = self.short.first;
            while (entry) |e| : (entry = e.next) {
                if (e.data.hash == hash) {
                    e.data.accessed.store(true, .release);
                    return e.data.data;
                }
            }

            entry = self.main.first;
            while (entry) |e| : (entry = e.next) {
                if (e.data.hash == hash) {
                    return e.data.data;
                }
            }

            return null;
        }

        fn release(self: *const @This(), node: *std.DoublyLinkedList(Entry).Node) void {
            if (@hasDecl(Data, "release")) {
                node.data.data.release();
            }
            self.allocator.destroy(node);
        }

        fn evictMain(self: *@This()) void {
            if (self.main.len <= main_size) {
                return;
            }

            const popped = self.main.pop() orelse return;
            self.release(popped);
        }

        fn evictShort(self: *@This()) void {
            if (self.short.len <= short_size) {
                return;
            }

            const popped = self.short.pop() orelse return;
            if (!popped.data.accessed.load(.unordered)) {
                self.release(popped);
                return;
            }

            self.main.prepend(popped);
        }

        pub fn put(self: *@This(), hash: u64, data: *Data) std.mem.Allocator.Error!void {
            if (@hasDecl(Data, "retain")) {
                _ = data.retain();
            }

            const node = try self.allocator.create(std.DoublyLinkedList(Entry).Node);
            node.* = .{
                .data = .{
                    .data = data,
                    .hash = hash,
                },
            };

            self.short.prepend(node);
            self.evictShort();
        }
    };
}

test DoubleFifoCache {
    const Cache = DoubleFifoCache(struct {
        n: u64,
        rc: usize = 0,

        pub fn retain(self: *@This()) void {
            self.rc += 1;
        }

        pub fn release(self: *@This()) void {
            self.rc -= 1;
        }
    }, 3, 10);

    var cache = Cache.init(std.testing.allocator);

    var n1 = Cache.Data{ .n = 1 };
    try cache.put(1, &n1);

    var n2 = Cache.Data{ .n = 2 };
    try cache.put(2, &n2);

    var n3 = Cache.Data{ .n = 3 };
    try cache.put(3, &n3);

    try std.testing.expectEqual(2, cache.get(2).?.n);
    try std.testing.expectEqual(3, cache.get(3).?.n);
    try std.testing.expect(cache.get(4) == null);

    try std.testing.expectEqual(3, cache.short.len);
    try std.testing.expectEqual(0, cache.main.len);

    var n4 = Cache.Data{ .n = 4 };
    try cache.put(4, &n4);

    try std.testing.expectEqual(4, cache.get(4).?.n);

    try std.testing.expectEqual(3, cache.short.len);
    try std.testing.expectEqual(0, cache.main.len);

    var n5 = Cache.Data{ .n = 5 };
    try cache.put(5, &n5);

    try std.testing.expect(cache.get(1) == null);
    try std.testing.expectEqual(2, cache.get(2).?.n);
    try std.testing.expectEqual(3, cache.get(3).?.n);
    try std.testing.expectEqual(4, cache.get(4).?.n);
    try std.testing.expectEqual(5, cache.get(5).?.n);

    try std.testing.expectEqual(3, cache.short.len);
    try std.testing.expectEqual(1, cache.main.len);

    try std.testing.expectEqual(0, n1.rc);
    try std.testing.expectEqual(1, n2.rc);
    try std.testing.expectEqual(1, n3.rc);
    try std.testing.expectEqual(1, n4.rc);
    try std.testing.expectEqual(1, n5.rc);

    cache.deinit();

    try std.testing.expectEqual(0, n1.rc);
    try std.testing.expectEqual(0, n2.rc);
    try std.testing.expectEqual(0, n3.rc);
    try std.testing.expectEqual(0, n4.rc);
    try std.testing.expectEqual(0, n5.rc);
}

pub const DownloaderOptions = struct {
    concurrent_download_limit: u5 = 10,
    short_cache_size: usize = 10,
    main_cache_size: usize = 50,
};

pub fn Downloader(opts: DownloaderOptions) type {
    return struct {
        const Job = struct {
            ready: std.Thread.Condition = .{},
            result: *GetResult = undefined,
            req_hash: u64,
            arc: Arc = .{},
        };

        const Cache = DoubleFifoCache(Image, opts.short_cache_size, opts.main_cache_size);

        // 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)) << opts.concurrent_download_limit),
        mutex: std.Thread.Mutex = .{},
        cond: std.Thread.Condition = .{},
        downloads_queue: std.DoublyLinkedList(Job) = .{},
        queue_mutex: std.Thread.Mutex = .{},
        http_client: std.http.Client,
        is_closed: bool = false,
        cache: Cache,

        pub fn init(allocator: std.mem.Allocator) @This() {
            return .{
                .http_client = std.http.Client{
                    .allocator = allocator,
                },
                .cache = Cache.init(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();
            self.cache.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([]const u8, 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);

            if (self.cache.get(req_hash)) |cached| {
                std.log.debug("Using cached image for {s}", .{url});
                return try GetResult.makeCachedRetained(cached);
            }

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

                var node = self.downloads_queue.first;
                while (node) |d| : (node = d.next) {
                    if (d.data.req_hash == req_hash) {
                        d.data.arc.ref();
                        defer if (d.data.arc.unref()) {
                            self.downloads_queue.remove(d);
                            allocator.destroy(d);
                        };

                        d.data.ready.wait(&self.queue_mutex);
                        return d.data.result.retain();
                    }
                }
            }

            const node = try allocator.create(std.DoublyLinkedList(Job).Node);
            node.* = .{
                .data = .{
                    .req_hash = req_hash,
                },
            };

            node.data.arc.ref();

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

                self.downloads_queue.prepend(node);
            }

            defer if (node.data.arc.unref()) {
                self.queue_mutex.lock();
                defer self.queue_mutex.unlock();

                self.downloads_queue.remove(node);
                allocator.destroy(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);

            if (get_result.image) |image| {
                self.cache.put(req_hash, image) catch {
                    std.log.warn("Unable to cache downloaded image due to out of memory error", .{});
                };
            }

            node.data.result = get_result;
            node.data.ready.broadcast();

            return get_result.retain();
        }
    };
}