package main

import "core:bufio"
import "core:fmt"
import "core:os"
import zmq "zmq"

main :: proc() {
	major, minor, patch := zmq.version()
	fmt.printfln("zmq echo (libzmq %d.%d.%d) over inproc; type lines, Ctrl-D to quit", major, minor, patch)

	ctx := zmq.new_context()
	defer zmq.term(ctx)

	rep := must_socket(ctx, .REP, "rep socket")
	defer zmq.close(rep)
	must(zmq.bind(rep, "inproc://echo"), "bind")

	req := must_socket(ctx, .REQ, "req socket")
	defer zmq.close(req)
	must(zmq.connect(req, "inproc://echo"), "connect")

	echo(req, rep)
}

echo :: proc(req, rep: zmq.Socket) {
	scanner: bufio.Scanner
	bufio.scanner_init(&scanner, os.to_reader(os.stdin))
	defer bufio.scanner_destroy(&scanner)

	buf: [1024]u8
	for bufio.scan(&scanner) {
		line := bufio.scanner_text(&scanner)
		if len(line) == 0 {
			continue
		}
		if _, err := zmq.send(req, transmute([]u8)line); !zmq.is_ok(err) {
			fmt.eprintfln("send: %s", zmq.error_string(err))
			return
		}
		n, rerr := zmq.recv(rep, buf[:])
		if !zmq.is_ok(rerr) {
			fmt.eprintfln("rep recv: %s", zmq.error_string(rerr))
			return
		}
		if _, werr := zmq.send(rep, buf[:n]); !zmq.is_ok(werr) {
			fmt.eprintfln("rep send: %s", zmq.error_string(werr))
			return
		}
		m, qerr := zmq.recv(req, buf[:])
		if !zmq.is_ok(qerr) {
			fmt.eprintfln("req recv: %s", zmq.error_string(qerr))
			return
		}
		fmt.println(string(buf[:m]))
	}
}

must :: proc(err: zmq.Error, at: string) {
	if !zmq.is_ok(err) {
		fatal(at, err)
	}
}

must_socket :: proc(ctx: zmq.Context, type: zmq.Socket_Type, at: string) -> zmq.Socket {
	s, err := zmq.socket(ctx, type)
	must(err, at)
	return s
}

fatal :: proc(at: string, err: zmq.Error) {
	fmt.eprintfln("%s: %s", at, zmq.error_string(err))
	os.exit(1)
}