package zmq

import "core:c"

foreign import lib "system:zmq"

@(default_calling_convention = "c")
foreign lib {
	@(link_name = "zmq_ctx_new")
	_ctx_new :: proc() -> rawptr ---
	@(link_name = "zmq_ctx_term")
	_ctx_term :: proc(ctx: rawptr) -> c.int ---
	@(link_name = "zmq_socket")
	_socket :: proc(ctx: rawptr, type: Socket_Type) -> rawptr ---
	@(link_name = "zmq_close")
	_close :: proc(s: rawptr) -> c.int ---
	@(link_name = "zmq_bind")
	_bind :: proc(s: rawptr, addr: cstring) -> c.int ---
	@(link_name = "zmq_connect")
	_connect :: proc(s: rawptr, addr: cstring) -> c.int ---
	@(link_name = "zmq_send")
	_send :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> c.int ---
	@(link_name = "zmq_recv")
	_recv :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> c.int ---
	@(link_name = "zmq_errno")
	_errno :: proc() -> c.int ---
	@(link_name = "zmq_strerror")
	_strerror :: proc(errnum: c.int) -> cstring ---
	@(link_name = "zmq_version")
	_version :: proc(major, minor, patch: ^c.int) ---
}

Context :: distinct rawptr
Socket :: distinct rawptr

Socket_Type :: enum c.int {
	PAIR   = 0,
	PUB    = 1,
	SUB    = 2,
	REQ    = 3,
	REP    = 4,
	DEALER = 5,
	ROUTER = 6,
	PULL   = 7,
	PUSH   = 8,
	XPUB   = 9,
	XSUB   = 10,
	STREAM = 11,
}

Flag :: enum c.int {
	DONTWAIT = 1,
	SNDMORE  = 2,
}

Flags :: bit_set[Flag;c.int]

NoBlock :: Flags{.DONTWAIT}

Error :: enum c.int {
	Ok,
}

strerror :: proc(e: Error) -> string {
	return string(_strerror(c.int(e)))
}

last_error :: proc() -> Error {return Error(_errno())}

version :: proc() -> (major, minor, patch: int) {
	ma, mi, pa: c.int = 0, 0, 0
	_version(&ma, &mi, &pa)
	return int(ma), int(mi), int(pa)
}

ctx_new :: proc() -> Context {
	return Context(_ctx_new())
}

ctx_term :: proc(ctx: Context) -> Error {
	return _ctx_term(rawptr(ctx)) == 0 ? .Ok : last_error()
}

socket :: proc(ctx: Context, type: Socket_Type) -> (Socket, Error) {
	s := _socket(rawptr(ctx), type)
	if s == nil {
		return nil, last_error()
	}
	return Socket(s), .Ok
}

close :: proc(s: Socket) -> Error {
	return _close(rawptr(s)) == 0 ? .Ok : last_error()
}

bind :: proc(s: Socket, addr: string) -> Error {
	return endpoint(rawptr(s), addr, _bind)
}

connect :: proc(s: Socket, addr: string) -> Error {
	return endpoint(rawptr(s), addr, _connect)
}

send :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
	n := _send(rawptr(s), rawptr(&buf[0]), c.size_t(len(buf)), transmute(c.int)flags)
	if n < 0 {
		return -1, last_error()
	}
	return int(n), .Ok
}

recv :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
	n := _recv(rawptr(s), rawptr(&buf[0]), c.size_t(len(buf)), transmute(c.int)flags)
	if n < 0 {
		return -1, last_error()
	}
	return int(n), .Ok
}

endpoint :: proc(
	s: rawptr,
	addr: string,
	f: proc "c" (s: rawptr, addr: cstring) -> c.int,
) -> Error {
	buf: [256]u8
	n := copy(buf[:], addr)
	if n >= len(buf) {
		return Error(7)
	}
	buf[n] = 0
	return f(s, cstring(rawptr(&buf[0]))) == 0 ? .Ok : last_error()
}