const is_debug = builtin.mode == .Debug;
const base64 = std.base64.Base64Encoder.init(std.base64.standard_alphabet_chars, '=');

const SaprusPacketType = enum(u16) {
    relay = 0x003C,
    file_transfer = 0x8888,
    connection = 0x00E9,
};

const SaprusConnectionOptions = packed struct(u8) {
    opt1: bool = false,
    opt2: bool = false,
    opt3: bool = false,
    opt4: bool = false,
    opt5: bool = false,
    opt6: bool = false,
    opt7: bool = false,
    opt8: bool = false,
};

const SaprusMessage = union(SaprusPacketType) {
    const Relay = struct {
        header: packed struct {
            dest: @Vector(4, u8),
        },
        payload: []const u8,
    };
    const Connection = struct {
        header: packed struct {
            src_port: u16,
            dest_port: u16,
            seq_num: u32 = 0,
            msg_id: u32 = 0,
            reserved: u8 = 0,
            options: SaprusConnectionOptions = .{},
        },
        payload: []const u8,
    };
    relay: Relay,
    file_transfer: void, // unimplemented
    connection: Connection,

    fn toBytes(self: SaprusMessage, allocator: Allocator) ![]u8 {
        var buf = std.ArrayList(u8).init(allocator);
        const w = buf.writer();
        try w.writeInt(u16, @intFromEnum(self), .big);

        switch (self) {
            .relay => |r| {
                try w.writeStructEndian(r.header, .big);
                try w.writeInt(u16, @intCast(r.payload.len), .big);
                try base64.encodeWriter(w, r.payload);
            },
            .file_transfer => unreachable,
            .connection => |c| {
                try w.writeStructEndian(c.header, .big);
                try w.writeInt(u16, @intCast(c.payload.len), .big);
                try base64.encodeWriter(w, c.payload);
            },
        }

        return buf.toOwnedSlice();
    }
};

pub fn main() !void {
    var dba: ?DebugAllocator = if (comptime is_debug) DebugAllocator.init else null;
    defer if (dba) |*d| {
        _ = d.deinit();
    };

    var gpa = if (dba) |*d| d.allocator() else std.heap.smp_allocator;

    const msg = SaprusMessage{
        .relay = .{
            .header = .{ .dest = .{ 255, 255, 255, 255 } },
            .payload = "Hello darkness my old friend",
        },
    };

    const msg_bytes = try msg.toBytes(gpa);
    defer gpa.free(msg_bytes);

    try network.init();
    defer network.deinit();

    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);
}

const builtin = @import("builtin");
const std = @import("std");
const Allocator = std.mem.Allocator;
const DebugAllocator = std.heap.DebugAllocator(.{});

const network = @import("network");