import context
import time
import x.async as xasync

fn test_every_runs_at_least_one_iteration() {
	parent_ctx, cancel := xasync.with_cancel()
	ran := chan bool{cap: 1}
	result := chan string{cap: 1}
	worker := spawn fn [parent_ctx, ran, result] () {
		xasync.every(parent_ctx, 5 * time.millisecond, fn [ran] (mut ctx context.Context) ! {
			_ = ctx
			ran <- true
		}) or {
			result <- err.msg()
			return
		}
		result <- 'ok'
	}()

	select {
		did_run := <-ran {
			assert did_run
		}
		1 * time.second {
			assert false, 'periodic job did not run'
		}
	}
	cancel()
	select {
		msg := <-result {
			assert msg == 'context canceled'
		}
		1 * time.second {
			assert false, 'every did not stop after cancellation'
		}
	}
	worker.wait()
}

fn test_every_stops_on_cancellation() {
	parent_ctx, cancel := xasync.with_cancel()
	entered := chan bool{cap: 1}
	result := chan string{cap: 1}
	worker := spawn fn [parent_ctx, entered, result] () {
		entered <- true
		xasync.every(parent_ctx, 1 * time.second, fn (mut ctx context.Context) ! {
			_ = ctx
		}) or {
			result <- err.msg()
			return
		}
		result <- 'ok'
	}()

	select {
		did_enter := <-entered {
			assert did_enter
		}
		1 * time.second {
			assert false, 'every worker did not start'
		}
	}
	cancel()
	select {
		msg := <-result {
			assert msg == 'context canceled'
		}
		1 * time.second {
			assert false, 'every did not stop on context cancellation'
		}
	}
	worker.wait()
}

fn test_every_returns_immediately_when_parent_is_already_canceled() {
	parent_ctx, cancel := xasync.with_cancel()
	cancel()
	xasync.every(parent_ctx, 1 * time.second, fn (mut ctx context.Context) ! {
		_ = ctx
	}) or {
		assert err.msg() == 'context canceled'
		return
	}
	assert false
}

fn test_every_returns_iteration_error() {
	parent_ctx, cancel := xasync.with_cancel()
	result := chan string{cap: 1}
	worker := spawn fn [parent_ctx, result] () {
		xasync.every(parent_ctx, 5 * time.millisecond, fn (mut ctx context.Context) ! {
			_ = ctx
			return error('periodic failed')
		}) or {
			result <- err.msg()
			return
		}
		result <- 'ok'
	}()

	select {
		msg := <-result {
			assert msg == 'periodic failed'
		}
		1 * time.second {
			assert false, 'every did not return the periodic job error'
		}
	}
	cancel()
	worker.wait()
}

fn test_every_rejects_zero_interval() {
	xasync.every(context.background(), 0 * time.millisecond, fn (mut ctx context.Context) ! {
		_ = ctx
	}) or {
		assert err.msg() == 'async: interval must be positive'
		return
	}
	assert false
}

fn test_every_rejects_negative_interval() {
	xasync.every(context.background(), -1 * time.millisecond, fn (mut ctx context.Context) ! {
		_ = ctx
	}) or {
		assert err.msg() == 'async: interval must be positive'
		return
	}
	assert false
}

fn test_every_rejects_nil_job() {
	nil_job := unsafe { xasync.JobFn(nil) }
	xasync.every(context.background(), 1 * time.second, nil_job) or {
		assert err.msg() == 'async: job function is nil'
		return
	}
	assert false
}

fn test_every_does_not_overlap_iterations() {
	parent_ctx, cancel := xasync.with_cancel()
	active := chan bool{cap: 1}
	active <- true
	entered := chan bool{cap: 2}
	release := chan bool{cap: 2}
	overlap := chan bool{cap: 1}
	result := chan string{cap: 1}
	worker := spawn fn [parent_ctx, active, entered, release, overlap, result] () {
		xasync.every(parent_ctx, 5 * time.millisecond, fn [active, entered, release, overlap] (mut ctx context.Context) ! {
			select {
				_ := <-active {}
				else {
					overlap <- true
					return error('periodic overlap')
				}
			}
			entered <- true
			done := ctx.done()
			select {
				_ := <-release {}
				_ := <-done {
					active <- true
					return ctx.err()
				}
			}
			active <- true
		}) or {
			result <- err.msg()
			return
		}
		result <- 'ok'
	}()

	wait_for_periodic_entry(entered)
	select {
		_ := <-entered {
			assert false, 'periodic iterations overlapped while first job was still running'
		}
		50 * time.millisecond {}
	}
	select {
		did_overlap := <-overlap {
			assert !did_overlap
		}
		else {}
	}

	release <- true
	wait_for_periodic_entry(entered)
	cancel()
	release <- true
	select {
		msg := <-result {
			assert msg == 'context canceled'
		}
		1 * time.second {
			assert false, 'every did not stop after non-overlap test cancellation'
		}
	}
	worker.wait()
}

fn test_start_every_rejects_invalid_interval() {
	xasync.start_every(context.background(), 0 * time.millisecond, fn (mut ctx context.Context) ! {
		_ = ctx
	}) or {
		assert err.msg() == 'async: interval must be positive'
		return
	}
	assert false
}

fn test_start_every_rejects_negative_interval() {
	xasync.start_every(context.background(), -1 * time.millisecond, fn (mut ctx context.Context) ! {
		_ = ctx
	}) or {
		assert err.msg() == 'async: interval must be positive'
		return
	}
	assert false
}

fn test_start_every_rejects_nil_job() {
	nil_job := unsafe { xasync.JobFn(nil) }
	xasync.start_every(context.background(), 1 * time.second, nil_job) or {
		assert err.msg() == 'async: job function is nil'
		return
	}
	assert false
}

fn test_start_every_returns_immediately_when_parent_is_already_canceled() {
	parent_ctx, cancel := xasync.with_cancel()
	cancel()
	xasync.start_every(parent_ctx, 1 * time.second, fn (mut ctx context.Context) ! {
		_ = ctx
	}) or {
		assert err.msg() == 'context canceled'
		return
	}
	assert false
}

fn test_periodic_handle_stop_before_first_iteration() {
	ran := chan bool{cap: 1}
	mut handle := xasync.start_every(context.background(), 1 * time.second, fn [ran] (mut ctx context.Context) ! {
		_ = ctx
		ran <- true
	})!
	handle.stop()
	handle.wait()!
	assert_no_periodic_signal(ran, 'periodic handle ran before first interval after stop')
}

fn test_periodic_handle_stop_between_ticks() {
	ticks := chan bool{cap: 2}
	mut handle := xasync.start_every(context.background(), 5 * time.millisecond, fn [ticks] (mut ctx context.Context) ! {
		_ = ctx
		ticks <- true
	})!
	wait_for_periodic_entry(ticks)
	handle.stop()
	handle.wait()!
	assert_no_periodic_signal(ticks, 'periodic handle ticked again after stop and wait')
}

fn test_periodic_handle_stop_during_long_job_waits_for_job_to_return() {
	entered := chan bool{cap: 1}
	release := chan bool{cap: 1}
	waited := chan bool{cap: 1}
	mut handle := xasync.start_every(context.background(), 5 * time.millisecond, fn [entered, release] (mut ctx context.Context) ! {
		_ = ctx
		entered <- true
		_ := <-release
	})!
	wait_for_periodic_entry(entered)
	handle.stop()

	wait_thread := spawn fn [mut handle, waited] () {
		handle.wait() or {
			waited <- false
			return
		}
		waited <- true
	}()
	assert_no_periodic_signal(waited, 'periodic handle wait returned before long job completed')
	release <- true
	wait_for_periodic_entry(waited)
	wait_thread.wait()
}

fn test_periodic_handle_wait_returns_job_error() {
	mut handle := xasync.start_every(context.background(), 5 * time.millisecond, fn (mut ctx context.Context) ! {
		_ = ctx
		return error('periodic handle failed')
	})!
	handle.wait() or {
		assert err.msg() == 'periodic handle failed'
		return
	}
	assert false
}

fn test_periodic_handle_wait_returns_job_context_canceled_error_after_stop() {
	entered := chan bool{cap: 1}
	release := chan bool{cap: 1}
	mut handle := xasync.start_every(context.background(), 5 * time.millisecond, fn [entered, release] (mut ctx context.Context) ! {
		_ = ctx
		entered <- true
		_ := <-release
		return error('context canceled')
	})!
	wait_for_periodic_entry(entered)
	handle.stop()
	release <- true
	handle.wait() or {
		assert err.msg() == 'context canceled'
		return
	}
	assert false, 'job-returned context canceled error was treated as normal stop'
}

fn test_periodic_handle_wait_returns_parent_cancellation() {
	parent_ctx, cancel := xasync.with_cancel()
	mut handle := xasync.start_every(parent_ctx, 1 * time.second, fn (mut ctx context.Context) ! {
		_ = ctx
	})!
	cancel()
	handle.wait() or {
		assert err.msg() == 'context canceled'
		return
	}
	assert false
}

fn test_periodic_handle_stop_after_parent_cancel_keeps_parent_error() {
	parent_ctx, cancel := xasync.with_cancel()
	mut handle := xasync.start_every(parent_ctx, 1 * time.second, fn (mut ctx context.Context) ! {
		_ = ctx
	})!
	cancel()
	handle.stop()
	handle.wait() or {
		assert err.msg() == 'context canceled'
		return
	}
	assert false
}

fn test_periodic_handle_does_not_overlap_iterations() {
	active := chan bool{cap: 1}
	active <- true
	entered := chan bool{cap: 2}
	release := chan bool{cap: 2}
	overlap := chan bool{cap: 1}
	mut handle := xasync.start_every(context.background(), 5 * time.millisecond, fn [active, entered, release, overlap] (mut ctx context.Context) ! {
		select {
			_ := <-active {}
			else {
				overlap <- true
				return error('periodic handle overlap')
			}
		}
		entered <- true
		_ = ctx
		_ := <-release
		active <- true
	})!

	wait_for_periodic_entry(entered)
	assert_no_periodic_signal(entered,
		'periodic handle iterations overlapped while first job was still running')
	select {
		did_overlap := <-overlap {
			assert !did_overlap
		}
		else {}
	}

	release <- true
	wait_for_periodic_entry(entered)
	handle.stop()
	release <- true
	handle.wait()!
	assert_no_periodic_signal(entered, 'periodic handle started another iteration after stop')
}

fn test_periodic_handle_double_stop_and_wait() {
	mut handle := xasync.start_every(context.background(), 1 * time.second, fn (mut ctx context.Context) ! {
		_ = ctx
	})!
	handle.stop()
	handle.stop()
	handle.wait()!
	handle.wait() or {
		assert err.msg() == 'async: periodic wait was already called'
		return
	}
	assert false
}

fn wait_for_periodic_entry(entered chan bool) {
	select {
		did_enter := <-entered {
			assert did_enter
		}
		1 * time.second {
			assert false, 'periodic job did not enter'
		}
	}
}

fn assert_no_periodic_signal(signal chan bool, message string) {
	select {
		_ := <-signal {
			assert false, message
		}
		50 * time.millisecond {}
	}
}