const std = @import("std");

const zapata = @import("./src/main.zig");
const Configuration = zapata.Configuration;
const Vm = zapata.Vm;
const ForeignClass = zapata.ForeignClass;
const Method = zapata.Method;

const EmptyUserData = struct {};

const ToWrenAndBack = struct {
    const Self = @This();

    n: i32,

    pub fn initialize1(self: *Self, vm: *Vm, n: i32) void {
        self.n = n;
    }

    pub fn call(self: *Self, vm: *Vm, message: []const u8) []const u8 {
        if (self.n == 42 and std.mem.eql(u8, "Though Wren to Zig...", message)) {
            std.debug.print("{s}\n", .{message});
            return "...and back!";
        }
        return "";
    }
};

pub fn main() !void {
    var config = Configuration{};
    config.registerForeignClasses(.{
        ForeignClass("ToWrenAndBack", ToWrenAndBack),
    });

    var vm: Vm = undefined;
    try config.newVmInPlace(EmptyUserData, &vm, null);
    defer vm.deinit();

    try vm.interpret("main",
        \\foreign class ToWrenAndBack {
        \\  construct new(n) {}
        \\  foreign call(message)
        \\}
        \\
        \\var twab = ToWrenAndBack.new(42)
    );

    const receiver = vm.makeReceiver("main", "twab");
    defer receiver.deinit();
    const call_sig = vm.makeCallHandle("call(_)");
    defer call_sig.deinit();

    const call = Method([]const u8, .{[]const u8}).init(receiver, call_sig);

    std.debug.print("{s}\n", .{try call.call(.{"Though Wren to Zig..."})});
}