var rand: ?Random = null;

pub fn init() !void {
    var prng = Random.DefaultPrng.init(blk: {
        var seed: u64 = undefined;
        try posix.getrandom(mem.asBytes(&seed));
        break :blk seed;
    });
    rand = prng.random();
    try network.init();
}

pub fn deinit() void {
    network.deinit();
}

fn broadcastSaprusMessage(msg: SaprusMessage, allocator: Allocator) !void {
    const msg_bytes = try msg.toBytes(allocator);
    defer allocator.free(msg_bytes);

    var sock = try network.Socket.create(.ipv4, .udp);
    defer sock.close();

    try sock.setBroadcast(true);

    // Bind to 0.0.0.0:0
    const bind_addr = network.EndPoint{
        .address = network.Address{ .ipv4 = network.Address.IPv4.any },
        .port = 0,
    };

    const dest_addr = network.EndPoint{
        .address = network.Address{ .ipv4 = network.Address.IPv4.broadcast },
        .port = 8888,
    };

    try sock.bind(bind_addr);

    _ = try sock.sendTo(dest_addr, msg_bytes);
}

pub fn sendRelay(payload: []const u8, allocator: Allocator) !void {
    const msg = SaprusMessage{
        .relay = .{
            .header = .{ .dest = .{ 255, 255, 255, 255 } },
            .payload = payload,
        },
    };

    try broadcastSaprusMessage(msg, allocator);
}

pub fn sendInitialConnection(payload: []const u8, initial_port: u16, allocator: Allocator) !SaprusMessage {
    var dest_port: u16 = 0;
    if (rand) |r| {
        dest_port = r.intRangeAtMost(u16, 1024, 65000);
    } else unreachable;

    const msg = SaprusMessage{
        .connection = .{
            .header = .{
                .src_port = initial_port,
                .dest_port = dest_port,
                .seq_num = 1,
                .msg_id = 2,
                .reserved = 5,
            },
            .payload = payload,
        },
    };

    try broadcastSaprusMessage(msg, allocator);

    return msg;
}

var setting_up_socket: std.Thread.Semaphore = std.Thread.Semaphore{};

fn awaitSentinelConnectionResponse(
    res: *?SaprusMessage,
    err: *?anyerror,
    allocator: Allocator,
) !void {
    var sock = try network.Socket.create(.ipv4, .udp);
    defer sock.close();

    // Bind to 255.255.255.255:8888
    const bind_addr = network.EndPoint{
        .address = network.Address{ .ipv4 = network.Address.IPv4.broadcast },
        .port = 8888,
    };

    try sock.setReadTimeout(1000);
    try sock.bind(bind_addr);

    // Signal that the socket is ready to receive data.
    setting_up_socket.post();

    var response_buf: [4096]u8 = undefined;

    _ = try sock.receive(&response_buf);
    const len = sock.receive(&response_buf) catch |e| {
        err.* = e;
        return;
    };

    res.* = try SaprusMessage.fromBytes(response_buf[0..len], allocator);
}

pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusMessage {
    var initial_port: u16 = 0;
    if (rand) |r| {
        initial_port = r.intRangeAtMost(u16, 1024, 65000);
    } else unreachable;

    var err: ?anyerror = null;
    var initial_conn_res: ?SaprusMessage = null;
    errdefer if (initial_conn_res) |c| c.deinit(allocator);

    const response_thread = try std.Thread.spawn(
        .{},
        awaitSentinelConnectionResponse,
        .{
            &initial_conn_res,
            &err,
            allocator,
        },
    );

    // Block until the socket is set up.
    try setting_up_socket.timedWait(500 * 1000 * 1000 * 1000);

    const msg = try sendInitialConnection(payload, initial_port, allocator);
    _ = msg;

    response_thread.join();

    return initial_conn_res;
}

const SaprusMessage = @import("./saprus_message.zig").SaprusMessage;

const std = @import("std");
const Random = std.Random;
const posix = std.posix;
const mem = std.mem;

const network = @import("network");

const Allocator = mem.Allocator;