/src/Roon/build_vapi.zig at 9783dfaace5761b88ec3a6ea17eec62a2247b925

// 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 ApiSpec = @import("./ApiSpec.zig");

fn writeBaseType(writer: anytype, t: ApiSpec.CBaseType) !void {
    switch (t) {
        .bool, .char, .float, .double, .string, .void => try writer.writeAll(@tagName(t)),
        .custom => |name| try writeCNameAsValaName(writer, name),
        .int => |bits| try std.fmt.format(writer, "int{d}", .{bits}),
        .uint => |bits| try std.fmt.format(writer, "uint{d}", .{bits}),
    }
}

fn writeType(writer: anytype, t: ApiSpec.CType) !void {
    switch (t) {
        .pointer => |pointer| {
            if (pointer.@"const" and pointer.type == .char) {
                try writer.writeAll("string");
                return;
            }

            try writeBaseType(writer, pointer.type);
        },
        .value => |child| try writeBaseType(writer, child),
    }
}

fn cnameToNamespaces(allocator: std.mem.Allocator, cname: []const u8) ![]const []const u8 {
    var ns = std.ArrayList([]const u8).init(allocator);
    defer ns.deinit();

    var iter = std.mem.splitScalar(u8, cname, '_');
    while (iter.next()) |token| {
        const buf = try allocator.dupe(u8, token);
        if (buf.len == 0) {
            continue;
        }

        buf[0] = std.ascii.toUpper(buf[0]);

        try ns.append(buf);
    }

    return ns.toOwnedSlice();
}

fn writeCNameAsValaName(writer: anytype, cname: []const u8) !void {
    var iter = std.mem.splitScalar(u8, cname, '_');
    while (iter.next()) |token| {
        if (token.len == 0) {
            continue;
        }

        try writer.writeByte(std.ascii.toUpper(token[0]));
        try writer.writeAll(token[1..]);
        if (iter.peek()) |_| {
            try writer.writeByte('.');
        }
    }
}

const CompactClassOptions = struct {
    name: []const u8,
    cname: []const u8,
    new_function: ?ApiSpec.Function = null,
    member_functions: []const ApiSpec.Function = &.{},
    fields: []const ApiSpec.StructField = &.{},
};

fn writeCompactClass(writer: anytype, opts: CompactClassOptions) !void {
    try writer.writeAll("[CCode (\n");
    try std.fmt.format(writer, "\tcname = \"{s}\",\n", .{opts.cname});
    try std.fmt.format(writer, "\tref_function = \"{s}_retain\",\n", .{opts.cname});
    try std.fmt.format(writer, "\tunref_function = \"{s}_release\"\n", .{opts.cname});
    try writer.writeAll(")]\n[Compact]\n");
    try std.fmt.format(writer, "public class {s} {{\n", .{opts.name});

    if (opts.new_function) |f| {
        try std.fmt.format(writer, "[CCode (cname = \"{s}_{s}\")]\n", .{ opts.cname, f.name });
        try std.fmt.format(writer, "public {s}", .{opts.name});
        if (!std.mem.eql(u8, f.name, "new")) {
            try std.fmt.format(writer, ".{s}", .{f.name});
        }
        try writer.writeByte('(');
        for (f.parameters, 0..) |param, i| {
            if (i > 0) {
                try writer.writeAll(", ");
            }
            try writeType(writer, param.type);
            try std.fmt.format(writer, " arg{d}", .{i});
        }
        try writer.writeAll(");\n");
    }

    for (opts.fields) |field| {
        if (std.mem.endsWith(u8, field.name, "_len")) {
            continue;
        }

        if (std.mem.endsWith(u8, field.name, "_ptr") and field.type == .pointer) {
            try std.fmt.format(
                writer,
                "[CCode (\n\tcname = \"{s}\",\n\tarray_length_cname = \"{s}_len\", array_length_type = \"size_t\"\n)]\n",
                .{ field.name, field.name[0 .. field.name.len - 4] },
            );

            try writer.writeAll("\tpublic ");
            try writeType(writer, field.type);
            try std.fmt.format(writer, "[] {s};\n", .{
                field.name[0 .. field.name.len - 4],
            });

            continue;
        }

        try writer.writeAll("\tpublic ");
        try writeType(writer, field.type);
        try std.fmt.format(writer, " {s};\n", .{field.name});
    }

    for (opts.member_functions) |f| {
        if (std.mem.startsWith(u8, f.name, "set_") and f.return_type == .value and f.return_type.value == .void) {
            if (f.parameters.len != 2) {
                std.log.err("Setter {s} on {s} does not have 2 parameters.", .{ f.name, opts.cname });
                return error.SetterNotHavingTwoParameters;
            }
            const value = f.parameters[1];

            try writer.writeAll("public ");
            try writeType(writer, value.type);
            try std.fmt.format(writer, " {s} {{\n\t[CCode (cname = \"{s}_{s}\")] set;\n}}\n", .{
                f.name[4..],
                opts.cname,
                f.name,
            });
            continue;
        }

        try std.fmt.format(writer, "[CCode (cname = \"{s}_{s}\")]\n", .{
            opts.cname,
            f.name,
        });
        try writer.writeAll("public ");
        try writeType(writer, f.return_type);
        try std.fmt.format(writer, " {s}(", .{f.name});
        for (f.parameters[1..], 0..) |param, i| {
            if (i > 0) {
                try writer.writeAll(", ");
            }
            try writeType(writer, param.type);
            try std.fmt.format(writer, " arg{d}", .{i});
        }
        try writer.writeAll(");\n");
    }

    try writer.writeAll("}\n");
}

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();

    const allocator = arena.allocator();

    var args = std.process.ArgIterator.init();
    defer args.deinit();

    _ = args.skip();

    const input = args.next() orelse {
        return error.NoInputFile;
    };

    const output = args.next() orelse {
        return error.NoOutputFile;
    };

    if (args.next()) |_| {
        return error.TooManyArgument;
    }

    const input_file = try std.fs.cwd().openFile(input, .{});
    defer input_file.close();

    var source = std.json.reader(allocator, input_file.reader());

    const parsed = try std.json.parseFromTokenSource(ApiSpec, allocator, &source, .{});
    defer parsed.deinit();

    const spec = parsed.value;

    const output_file = try std.fs.cwd().createFile(output, .{});
    defer output_file.close();

    const writer = output_file.writer();

    for (spec.items) |item| {
        switch (item) {
            .@"enum" => |info| {
                const components = try cnameToNamespaces(allocator, info.cname);
                const ns = components[0 .. components.len - 1];
                const name = components[components.len - 1];

                try writer.writeAll("[CCode (cheader_filename = \"roon.h\")]\n");
                for (ns) |token| {
                    try std.fmt.format(writer, "namespace {s} {{\n", .{token});
                }

                try writer.writeAll("[CCode (\n");
                try std.fmt.format(writer, "\tcname = \"{s}\",\n", .{info.cname});
                try std.fmt.format(writer, "\tcprefix = \"{s}_\",\n", .{
                    try std.ascii.allocUpperString(allocator, info.cname),
                });
                try writer.writeAll("\thas_type_id = false\n)]\n");

                try std.fmt.format(writer, "public enum {s} {{\n", .{name});

                for (info.fields) |field| {
                    try std.fmt.format(writer, "\t{s} = {d},\n", .{
                        try std.ascii.allocUpperString(allocator, field.name),
                        field.value,
                    });
                }

                try writer.writeAll("}\n");

                for (ns) |_| {
                    try writer.writeAll("}\n");
                }
            },
            .@"struct" => |info| {
                const components = try cnameToNamespaces(allocator, info.cname);
                const ns = components[0 .. components.len - 1];
                const name = components[components.len - 1];

                try writer.writeAll("[CCode (cheader_filename = \"roon.h\")]\n");
                for (ns) |token| {
                    try std.fmt.format(writer, "namespace {s} {{\n", .{token});
                }

                try writeCompactClass(writer, .{
                    .name = name,
                    .cname = info.cname,
                    .fields = info.fields,
                    .new_function = info.new_function,
                    .member_functions = info.member_functions,
                });

                for (ns) |_| {
                    try writer.writeAll("}\n");
                }
            },
            .@"opaque" => |info| {
                const components = try cnameToNamespaces(allocator, info.cname);
                const ns = components[0 .. components.len - 1];
                const name = components[components.len - 1];

                try writer.writeAll("[CCode (cheader_filename = \"roon.h\")]\n");
                for (ns) |token| {
                    try std.fmt.format(writer, "namespace {s} {{\n", .{token});
                }

                try writeCompactClass(writer, .{
                    .name = name,
                    .cname = info.cname,
                    .new_function = info.new_function,
                    .member_functions = info.member_functions,
                });

                for (ns) |_| {
                    try writer.writeAll("}\n");
                }
            },
        }

        try writer.writeByte('\n');
    }
}