import context
import time
import x.async as xasync

fn test_task_returns_value() {
	mut task := xasync.run[int](fn (mut ctx context.Context) !int {
		_ = ctx
		return 42
	})!
	assert task.wait()! == 42
}

fn test_task_returns_error() {
	mut task := xasync.run[int](fn (mut ctx context.Context) !int {
		_ = ctx
		return error('task failed')
	})!
	task.wait() or {
		assert err.msg() == 'task failed'
		return
	}
	assert false
}

fn test_task_wait_is_one_shot() {
	mut task := xasync.run[string](fn (mut ctx context.Context) !string {
		_ = ctx
		return 'ok'
	})!
	assert task.wait()! == 'ok'
	task.wait() or {
		assert err.msg() == 'async: task wait was already called'
		return
	}
	assert false
}

fn test_task_concurrent_wait_is_one_shot_without_deadlock() {
	release := chan bool{cap: 1}
	results := chan string{cap: 2}
	mut task := xasync.run[int](fn [release] (mut ctx context.Context) !int {
		_ = ctx
		_ := <-release
		return 7
	})!

	first_waiter := spawn fn [mut task, results] () {
		value := task.wait() or {
			results <- 'error:${err.msg()}'
			return
		}
		results <- 'value:${value}'
	}()
	second_waiter := spawn fn [mut task, results] () {
		value := task.wait() or {
			results <- 'error:${err.msg()}'
			return
		}
		results <- 'value:${value}'
	}()
	release <- true

	mut saw_value := false
	mut saw_second_wait_error := false
	for _ in 0 .. 2 {
		select {
			result := <-results {
				match result {
					'value:7' {
						saw_value = true
					}
					'error:async: task wait was already called' {
						saw_second_wait_error = true
					}
					else {
						assert false, 'unexpected concurrent wait result: ${result}'
					}
				}
			}
			1 * time.second {
				assert false, 'concurrent task waiters did not both finish'
			}
		}
	}
	first_waiter.wait()
	second_waiter.wait()

	assert saw_value
	assert saw_second_wait_error
}

fn test_task_parent_cancellation_is_observed() {
	parent_ctx, cancel := xasync.with_cancel()
	mut task := xasync.run_with_context[int](parent_ctx, fn (mut ctx context.Context) !int {
		done := ctx.done()
		select {
			_ := <-done {
				return ctx.err()
			}
			1 * time.second {
				return error('task did not observe parent cancellation')
			}
		}
		return error('unreachable')
	})!
	cancel()
	task.wait() or {
		assert err.msg() == 'context canceled'
		return
	}
	assert false
}

fn test_task_parent_already_canceled_is_observed() {
	parent_ctx, cancel := xasync.with_cancel()
	cancel()
	mut task := xasync.run_with_context[int](parent_ctx, fn (mut ctx context.Context) !int {
		done := ctx.done()
		select {
			_ := <-done {
				return ctx.err()
			}
			1 * time.second {
				return error('task did not observe already canceled parent')
			}
		}
		return error('unreachable')
	})!
	task.wait() or {
		assert err.msg() == 'context canceled'
		return
	}
	assert false
}

fn test_task_observes_context_done() {
	parent_ctx, cancel := xasync.with_cancel()
	observed := chan bool{cap: 1}
	mut task := xasync.run_with_context[int](parent_ctx, fn [observed] (mut ctx context.Context) !int {
		done := ctx.done()
		select {
			_ := <-done {
				observed <- true
				return ctx.err()
			}
			1 * time.second {
				observed <- false
				return error('task did not observe ctx.done()')
			}
		}
		return error('unreachable')
	})!
	cancel()
	task.wait() or { assert err.msg() == 'context canceled' }
	select {
		did_observe := <-observed {
			assert did_observe
		}
		1 * time.second {
			assert false, 'task did not report cancellation observation'
		}
	}
}

fn test_task_ignores_cancellation_but_result_publication_is_buffered() {
	parent_ctx, cancel := xasync.with_cancel()
	mut task := xasync.run_with_context[int](parent_ctx, fn (mut ctx context.Context) !int {
		_ = ctx
		time.sleep(20 * time.millisecond)
		return 9
	})!
	cancel()
	time.sleep(60 * time.millisecond)
	assert task.wait()! == 9
}

fn test_task_refuses_nil_function() {
	nil_task_fn := unsafe { xasync.TaskFn[int](nil) }
	xasync.run[int](nil_task_fn) or {
		assert err.msg() == 'async: job function is nil'
		return
	}
	assert false
}