import context
import time
import x.async as xasync

fn main() {
    mut pool := xasync.new_pool(workers: 1, queue_size: 1)!
    started := chan bool{cap: 2}
    release := chan bool{cap: 2}
    accepted := chan bool{cap: 1}
    ran := chan bool{cap: 1}
    context_ran := chan bool{cap: 1}
    blocking_job := fn [started, release] (mut ctx context.Context) ! {
        _ = ctx
        started <- true
        _ := <-release
    }

    pool.try_submit(blocking_job)!
    if !wait_bool(started) {
        eprintln('first pool job did not start')
        exit(1)
    }
    pool.try_submit(blocking_job)!

    submitter := spawn fn [mut pool, accepted, ran] () {
        pool.submit_with_timeout(1 * time.second, fn [ran] (mut ctx context.Context) ! {
            _ = ctx
            ran <- true
        }) or {
            eprintln('bounded submit failed: ${err.msg()}')
            accepted <- false
            return
        }
        accepted <- true
    }()

    release <- true
    if !wait_bool(accepted) {
        eprintln('bounded submit was not accepted after capacity opened')
        exit(1)
    }

    release <- true
    if !wait_bool(ran) {
        eprintln('bounded submit job did not run')
        exit(1)
    }

    parent_ctx, cancel := xasync.with_cancel()
    defer {
        cancel()
    }
    pool.submit_with_context(parent_ctx, fn [context_ran] (mut ctx context.Context) ! {
        _ = ctx
        context_ran <- true
    })!
    if !wait_bool(context_ran) {
        eprintln('context-bounded submit job did not run')
        exit(1)
    }

    pool.close()!
    submitter.wait()
    println('timeout and context bounded submits completed')
}

fn wait_bool(ch chan bool) bool {
    select {
        ok := <-ch {
            return ok
        }
        1 * time.second {
            return false
        }
    }
    return false
}