const std = @import("std");
const zaprus = @import("zaprus");

// Opaque types for C API
const ZaprusClient = opaque {};
const ZaprusConnection = opaque {};

const alloc = std.heap.c_allocator;
const io = std.Io.Threaded.global_single_threaded.io();

export fn zaprus_init_client() ?*ZaprusClient {
    const client = alloc.create(zaprus.Client) catch return null;
    client.* = zaprus.Client.init() catch {
        alloc.destroy(client);
        return null;
    };
    return @ptrCast(client);
}

export fn zaprus_deinit_client(client: ?*ZaprusClient) void {
    const c: ?*zaprus.Client = @ptrCast(@alignCast(client));
    if (c) |zc| {
        zc.deinit();
        alloc.destroy(zc);
    }
}

export fn zaprus_client_send_relay(
    client: ?*ZaprusClient,
    payload: [*c]const u8,
    payload_len: usize,
    dest: [*c]const u8,
) c_int {
    const c: ?*zaprus.Client = @ptrCast(@alignCast(client));
    const zc = c orelse return 1;

    zc.sendRelay(io, payload[0..payload_len], dest[0..4].*) catch return 1;
    return 0;
}

export fn zaprus_connect(
    client: ?*ZaprusClient,
    payload: [*c]const u8,
    payload_len: usize,
) ?*ZaprusConnection {
    const c: ?*zaprus.Client = @ptrCast(@alignCast(client));
    const zc = c orelse return null;

    const connection = alloc.create(zaprus.Connection) catch return null;
    connection.* = zc.connect(io, payload[0..payload_len]) catch {
        alloc.destroy(connection);
        return null;
    };
    return @ptrCast(connection);
}

export fn zaprus_deinit_connection(connection: ?*ZaprusConnection) void {
    const c: ?*zaprus.Connection = @ptrCast(@alignCast(connection));
    if (c) |zc| {
        alloc.destroy(zc);
    }
}

export fn zaprus_connection_next(
    connection: ?*ZaprusConnection,
    out: [*c]u8,
    capacity: usize,
    out_len: *usize,
) c_int {
    const c: ?*zaprus.Connection = @ptrCast(@alignCast(connection));
    const zc = c orelse return 1;

    const result = zc.next(io, out[0..capacity]) catch return 1;
    out_len.* = result.len;
    return 0;
}

export fn zaprus_connection_send(
    connection: ?*ZaprusConnection,
    payload: [*c]const u8,
    payload_len: usize,
) c_int {
    const c: ?*zaprus.Connection = @ptrCast(@alignCast(connection));
    const zc = c orelse return 1;

    zc.send(io, payload[0..payload_len]) catch return 1;
    return 0;
}