import os
import os.cmdline
import time
import sync

// Usage:
// many_writers_and_receivers_on_1_channel [-readers 1] [-writers 4] [-chan_cap 100] [-iterations 25000] > results.csv
//
// You can then open results.csv in Excel/Calc and for example plot the first vs the second column.
enum EventKind {
	push
	pop
}

struct Event {
	is_set  bool
	id      int
	gtime   u64 // nanoseconds
	i       int
	kind    EventKind
	elapsed i64 // nanoseconds, elapsed after the previous event of the same kind
}

struct Context {
mut:
	n_iters   int
	n_readers int
	n_writers int

	pops_wg &sync.WaitGroup
	pops    []Event

	pushes_wg &sync.WaitGroup
	pushes    []Event
}

fn do_rec(ch chan int, id int, mut ctx Context) {
	eprintln('start of  do_rec id: ${id}')
	mut timer_sw_x := time.new_stopwatch()
	mut tmp := int(0)
	mut i := int(0)
	// Note: a single receiver thread can get slightly more
	// than its fair share of sends, that is why
	// the receiver's Event array is much larger,
	// enough so a single receiver can potentially process all
	// writers pushes, and it is partitioned over all of
	// id, ctx.n_writers and n_iters:
	n_iters := ctx.n_iters
	base := id * n_iters * ctx.n_writers
	for {
		for ch.try_pop(mut tmp) == .success {
			ctx.pops[base + i] = Event{
				is_set:  true
				id:      id
				gtime:   time.sys_mono_now()
				i:       i
				kind:    .pop
				elapsed: timer_sw_x.elapsed().nanoseconds()
			}
			timer_sw_x.restart()
			i++
			if tmp == 1 {
				ctx.pops_wg.done()
				return
			}
		}
	}
}

fn do_send(ch chan int, id int, mut ctx Context) {
	eprintln('start of do_send id: ${id}')
	mut timer_sw_x := time.new_stopwatch()
	n_iters := ctx.n_iters
	base := n_iters * id // sender events can not overlap
	for i := 0; i < n_iters; i++ {
		idx := base + i
		ctx.pushes[idx] = Event{
			is_set:  true
			id:      id
			gtime:   time.sys_mono_now()
			i:       i
			kind:    .push
			elapsed: timer_sw_x.elapsed().nanoseconds()
		}
		timer_sw_x.restart()
		tmp := int(0)
		ch <- tmp
	}
	ctx.pushes_wg.done()
}

fn main() {
	args := os.args[1..]
	if '-h' in args || '--help' in args {
		eprintln('Usage:\n many_writers_and_receivers_on_1_channel [-readers 1] [-writers 4] [-chan_cap 100] [-iterations 25000]')
		exit(0)
	}
	n_iters := cmdline.option(args, '-iterations', '25000').int()
	n_readers := cmdline.option(args, '-readers', '1').int()
	n_writers := cmdline.option(args, '-writers', '4').int()
	chan_cap := cmdline.option(args, '-chan_cap', '100').int()
	eprintln('> n_iters, ${n_iters}, n_writers, ${n_writers}, n_readers, ${n_readers}, chan_cap, ${chan_cap}')

	ch := chan int{cap: chan_cap}
	max_number_of_pushes := n_writers * (n_iters + 2)
	max_number_of_pops := max_number_of_pushes * n_readers
	eprintln('> max_number_of_pushes, ${max_number_of_pushes}, max_number_of_pops (per receiver), ${max_number_of_pops}')
	mut ctx := &Context{
		n_iters:   n_iters
		n_readers: n_readers
		n_writers: n_writers
		pushes_wg: sync.new_waitgroup()
		pops_wg:   sync.new_waitgroup()
		pushes:    []Event{len: max_number_of_pushes}
		pops:      []Event{len: max_number_of_pops}
	}
	ctx.pops_wg.add(n_readers)
	for i := 0; i < n_readers; i++ {
		spawn do_rec(ch, i, mut ctx)
	}
	ctx.pushes_wg.add(n_writers)
	for i := 0; i < n_writers; i++ {
		spawn do_send(ch, i, mut ctx)
	}
	ctx.pushes_wg.wait()
	eprintln('>> all pushes done')
	for i := 0; i < n_readers; i++ {
		ch <- 1
	}
	ctx.pops_wg.wait()
	eprintln('>> all pops done')
	mut all_events := []Event{}
	all_events << ctx.pops
	all_events << ctx.pushes
	all_events.sort(a.elapsed < b.elapsed)
	mut i := 0
	for e in all_events {
		if !e.is_set {
			continue
		}
		i++
		if e.kind == .pop {
			println('${i:8} , ${e.elapsed:10}, ns ,  do_rec id:, ${e.id:3} , i=, ${e.i:5} , ${e.gtime:20}')
		}
		if e.kind == .push {
			println('${i:8} , ${e.elapsed:10}, ns , do_send id:, ${e.id:3} , i=, ${e.i:5} , ${e.gtime:20}')
		}
	}
}
