/core/src/image.zig at 52fba2355cc13be2b4b85a9aa6cb6e3eea21d85b

// 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 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,
};

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

    internal: *Internal,

    const Internal = struct {
        arc: Arc = .{},
        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.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.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 = .{},
    };

    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();
    }

    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();
}