.{math: .{Vec2}, buffer, memory} := @use("../../stn/src/lib.hb");
.{Surface} := @use("../../render/src/lib.hb")

$BUFFER_SERVER := "sunset_server\0"
$BUFFER_CLIENT := "sunset_client\0"

Channel := packed struct {
	client: uint,
	server: uint,
}

client := @use("./client.hb")
server := @use("./server.hb")
message := @use("./message.hb")
permissions := @use("./permissions.hb")

$send_message := fn($Expr: type, kind: uint, msg: Expr, buffer_id: uint): void {
	buffer.write(?Message(Expr), buffer_id, &@as(?Message(Expr), .(.(kind), msg)))
}

$send_header := fn(kind: uint, buffer_id: uint): void {
	buffer.write(?MessageHeader, buffer_id, &@as(?MessageHeader, .(kind)))
}

$recv_message := fn($Expr: type, buffer_id: uint): Message(Expr) {
	response := @as(?Message(Expr), null)
	buffer.recv(?Message(Expr), buffer_id, &response)
	return response
}

$recv_header := fn(buffer_id: uint): ?MessageHeader {
	response := @as(?MessageHeader, null)
	buffer.recv(?MessageHeader, buffer_id, &response)
	return response
}

await_channel := fn(channel: Channel): Channel {
	loop if channel.server != 0 break else {
		channel.server = buffer.search(BUFFER_SERVER)
	}
	loop if channel.client != 0 break else {
		channel.client = buffer.search(BUFFER_CLIENT)
	}
	return channel
}

await_message := fn($Expr: type, buffer_id: uint): Message(Expr) {
	response := @as(?Message(Expr), null)
	loop {
		buffer.recv(?Message(Expr), buffer_id, &response)
		if response != null {
			return @as(Message(Expr), response)
		}
	}
}

await_header := fn(buffer_id: uint): MessageHeader {
	response := @as(?MessageHeader, null)
	loop {
		buffer.recv(?MessageHeader, buffer_id, &response)
		if response != null {
			return @as(?MessageHeader, response)
		}
	}
}

MessageHeader := packed struct {
	kind: uint,
}

Message := fn($Expr: type): type {
	return packed struct {
		header: MessageHeader,
		body: Expr,
	}
}

WindowProps := struct {
	position: Vec2(uint),
	dimensions: Vec2(uint),
	// ! replace with owned string type later
	title: ^u8,
}

WindowData := struct {
	props: WindowProps,
	channel: Channel,
	permissions: uint,
}

Window := struct {
	data: WindowData,
	surface: Surface,
}