1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97

// SPDX-FileCopyrightText: 2025 Shota FUJI <pockawoooh@gmail.com>
// SPDX-License-Identifier: AGPL-3.0-only

const std = @import("std");

const Core = @import("Core.zig");

export fn init_core() *Core {
    // TODO: Handle OOM
    var core = std.heap.wasm_allocator.create(Core) catch unreachable;
    core.populate(std.heap.wasm_allocator);

    return core;
}

export fn deinit_core(core: *Core) void {
    std.heap.wasm_allocator.destroy(core);
}

export fn allocate_bytes(len: usize) [*]u8 {
    const slice = std.heap.wasm_allocator.alloc(u8, len) catch unreachable;

    return slice.ptr;
}

export fn free_bytes(ptr: [*]u8, len: usize) void {
    std.heap.wasm_allocator.free(ptr[0..len]);
}

const Response = extern struct {
    ptr: [*]const u8,
    len: usize,

    pub fn populate(self: *Response, slice: []const u8) void {
        const dst = std.heap.wasm_allocator.alloc(u8, slice.len) catch unreachable;
        @memcpy(dst, slice);
        self.ptr = dst.ptr;
        self.len = dst.len;
    }

    pub fn deinit(self: *Response) void {
        std.heap.wasm_allocator.free(self.ptr[0..self.len]);
        self.* = undefined;
    }
};

export fn create_response() *Response {
    const response = std.heap.wasm_allocator.create(Response) catch unreachable;
    return response;
}

export fn get_response_ptr(self: *const Response) [*]const u8 {
    return self.ptr;
}

export fn get_response_len(self: *const Response) usize {
    return self.len;
}

export fn destroy_response(response: *Response) void {
    response.deinit();
    std.heap.wasm_allocator.destroy(response);
}

const HandleResult = enum(u8) {
    ok = 0,
    unknown_service = 1,
    unknown_method = 2,
    decode_error = 3,
    encode_error = 4,
};

export fn handle(
    core: *const Core,
    service_ptr: [*]const u8,
    service_len: usize,
    method_ptr: [*]const u8,
    method_len: usize,
    bytes_ptr: [*]const u8,
    bytes_len: usize,
    resp_ptr: *Response,
) HandleResult {
    const resp = core.handle(
        service_ptr[0..service_len],
        method_ptr[0..method_len],
        bytes_ptr[0..bytes_len],
    ) catch |err| return switch (err) {
        Core.HandleError.UnknownMethod => .unknown_method,
        Core.HandleError.UnknownService => .unknown_service,
        Core.HandleError.DecodeError => .decode_error,
        Core.HandleError.EncodeError => .encode_error,
    };

    resp_ptr.populate(resp);

    return .ok;
}