module sync

import time
import sync.stdatomic

fn issue_6870_worker(mut wg WaitGroup, ready chan bool, release chan bool) {
	ready <- true
	_ = <-release
	wg.add(1)
	wg.done()
	wg.done()
}

fn test_waitgroup_reuse() {
	mut wg := new_waitgroup()

	wg.add(1)
	wg.done()

	wg.add(1)
	mut executed := false
	spawn fn (mut wg WaitGroup, executed voidptr) {
		defer {
			wg.done()
		}
		unsafe {
			*(&bool(executed)) = true
		}
		time.sleep(100 * time.millisecond)
	}(mut wg, voidptr(&executed))

	wg.wait()
	assert executed
}

fn test_waitgroup_no_use() {
	done := chan bool{cap: 1}
	watchdog := spawn fn (done chan bool) {
		select {
			_ := <-done {}
			10 * time.second {
				panic('test_waitgroup_no_use did not complete in time')
			}
		}
	}(done)

	mut wg := new_waitgroup()
	wg.wait()
	done <- true
	watchdog.wait()
}

fn test_waitgroup_go() {
	mut counter := stdatomic.new_atomic(0)
	mut wg := new_waitgroup()
	for i in 0 .. 10 {
		wg.go(fn [mut counter] () {
			counter.add(1)
		})
	}
	wg.wait()
	assert counter.load() == 10
}

fn test_waitgroup_add_while_waiting() {
	for _ in 0 .. 50 {
		mut wg := new_waitgroup()
		ready := chan bool{cap: 1}
		release := chan bool{cap: 1}
		wait_done := chan bool{cap: 8}
		wg.add(1)

		spawn issue_6870_worker(mut wg, ready, release)
		_ = <-ready

		for _ in 0 .. 8 {
			spawn fn [mut wg, wait_done] () {
				wg.wait()
				wait_done <- true
			}()
		}
		release <- true

		for _ in 0 .. 8 {
			select {
				_ := <-wait_done {}
				2 * time.second {
					assert false, 'wait() missed a wakeup while work added more tasks'
				}
			}
		}
	}
}