module async

import context
import time

// every runs f repeatedly with interval spacing until ctx is canceled or f fails.
//
// This helper is intentionally blocking: it does not start a hidden scheduler or
// background loop. The first iteration runs after one interval. Iterations never
// overlap; a slow job delays the next interval. Cancellation is cooperative, so
// a running job must observe `ctx.done()` if it needs to stop before returning.
pub fn every(parent context.Context, interval time.Duration, f JobFn) ! {
	if interval.nanoseconds() <= 0 {
		return error(err_interval_invalid)
	}
	if f == unsafe { nil } {
		return error(err_nil_job)
	}

	mut ctx := parent
	initial_err := ctx.err()
	if initial_err !is none {
		return initial_err
	}

	done_ch := ctx.done()
	mut watch_done := true
	// context.background().done() is closed in V but err() remains none. Treat
	// that as a non-cancelable context instead of returning immediately.
	select {
		_ := <-done_ch {
			err := ctx.err()
			if err !is none {
				return err
			}
			watch_done = false
		}
		else {}
	}

	for {
		if watch_done {
			select {
				_ := <-done_ch {
					err := ctx.err()
					if err !is none {
						return err
					}
					watch_done = false
				}
				interval {
					run_periodic_iteration(mut ctx, f)!
				}
			}
		} else {
			time.sleep(interval)
			run_periodic_iteration(mut ctx, f)!
		}
	}
}

fn run_periodic_iteration(mut ctx context.Context, f JobFn) ! {
	f(mut ctx)!
	err := ctx.err()
	if err !is none {
		return err
	}
}