/src/core/discovery.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 moo = @import("moo");
const sood = @import("sood");
const websocket = @import("websocket");

const Arc = @import("./Arc.zig");
const freelog = @import("./log.zig").freelog;
const RegistryService = @import("./services/registry.zig").RegistryService;

pub const Server = extern struct {
    const cname = "plac_discovery_server";
    const allocator = std.heap.c_allocator;

    internal: *Internal,
    id: [*:0]const u8,
    name: [*:0]const u8,
    version: [*:0]const u8,
    ip_addr: [*:0]const u8,
    http_port: u16,

    pub const Internal = struct {
        address: std.net.Address,
        arc: Arc = .{},
    };

    pub fn make(resp: *const sood.discovery.Response, addr: *const std.net.Address) !*Server {
        const self = try allocator.create(Server);
        errdefer allocator.destroy(self);

        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        const id = try allocator.dupeZ(u8, resp.unique_id);
        errdefer allocator.free(id);

        const name = try allocator.dupeZ(u8, resp.name);
        errdefer allocator.free(name);

        const version = try allocator.dupeZ(u8, resp.display_version);
        errdefer allocator.free(version);

        var ip_addr_buf = std.ArrayList(u8).init(allocator);
        defer ip_addr_buf.deinit();

        try std.fmt.format(ip_addr_buf.writer(), "{}", .{addr});
        if (std.mem.lastIndexOfScalar(u8, ip_addr_buf.items, ':')) |last_colon| {
            ip_addr_buf.shrinkAndFree(last_colon);
        }

        const ip_addr = try allocator.dupeZ(u8, ip_addr_buf.items);
        errdefer allocator.free(ip_addr);

        var address = addr.*;
        address.setPort(resp.http_port);

        internal.* = .{
            .address = address,
        };

        self.* = .{
            .internal = internal,
            .id = id.ptr,
            .name = name.ptr,
            .version = version.ptr,
            .ip_addr = ip_addr.ptr,
            .http_port = resp.http_port,
        };

        return self;
    }

    fn init(
        id: [*:0]const u8,
        name: [*:0]const u8,
        version: [*:0]const u8,
        ip_addr: [*:0]const u8,
        http_port: u16,
    ) !*Server {
        const self = try allocator.create(Server);
        errdefer allocator.destroy(self);

        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        const id_copy = try allocator.dupeZ(u8, std.mem.span(id));
        errdefer allocator.free(id_copy);

        const name_copy = try allocator.dupeZ(u8, std.mem.span(name));
        errdefer allocator.free(name_copy);

        const version_copy = try allocator.dupeZ(u8, std.mem.span(version));
        errdefer allocator.free(version_copy);

        const ip_addr_slice = std.mem.span(ip_addr);

        const ip_addr_copy = try allocator.dupeZ(u8, ip_addr_slice);
        errdefer allocator.free(ip_addr_copy);

        const colon = std.mem.indexOfScalar(u8, ip_addr_slice, ':') orelse {
            return error.UnexpectedIpFormat;
        };

        const internal_addr = try std.net.Address.parseIp4(ip_addr_slice[0..colon], http_port);

        internal.* = .{
            .address = internal_addr,
        };

        self.* = .{
            .internal = internal,
            .id = id_copy.ptr,
            .name = name_copy.ptr,
            .version = version_copy.ptr,
            .ip_addr = ip_addr_copy.ptr,
            .http_port = http_port,
        };

        return self;
    }

    pub fn new(
        id: [*:0]const u8,
        name: [*:0]const u8,
        version: [*:0]const u8,
        ip_addr: [*:0]const u8,
        http_port: u16,
    ) callconv(.C) ?*Server {
        return init(id, name, version, ip_addr, http_port) catch |err| {
            std.log.err("Unable to construct Discovery.Server: {s}", .{@errorName(err)});
            return null;
        };
    }

    pub fn retain(ptr: ?*Server) callconv(.C) *Server {
        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: ?*Server) 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(std.mem.span(self.id));
            allocator.free(std.mem.span(self.name));
            allocator.free(std.mem.span(self.version));
            allocator.free(std.mem.span(self.ip_addr));
            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}) });
        @export(&new, .{ .name = std.fmt.comptimePrint("{s}_new", .{cname}) });
    }
};

pub fn export_capi() void {
    Server.export_capi();
}