module async

import context
import sync
import time

enum PeriodicResultKind {
	completed
	job_error
	context_error
}

struct PeriodicResult {
	kind PeriodicResultKind
	err  IError = none
}

// PeriodicHandle owns one detached periodic loop started by start_every().
//
// The handle exposes only explicit lifecycle operations: stop() requests
// cooperative shutdown, and wait() consumes the loop result once.
@[heap]
pub struct PeriodicHandle {
mut:
	parent           context.Context
	ctx              context.Context
	cancel           context.CancelFn = unsafe { nil }
	result_ch        chan PeriodicResult
	mutex            &sync.Mutex = sync.new_mutex()
	stopped          bool
	stop_owns_cancel bool
	waited           bool
}

// 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)!
		}
	}
}

// start_every starts f in one detached periodic loop and returns its lifecycle handle.
//
// The first iteration runs after one interval. Iterations never overlap; a slow
// job delays the next interval. The returned handle must be stopped and waited
// on by its owner, otherwise the detached loop can keep running.
pub fn start_every(parent context.Context, interval time.Duration, f JobFn) !&PeriodicHandle {
	if interval.nanoseconds() <= 0 {
		return error(err_interval_invalid)
	}
	if f == unsafe { nil } {
		return error(err_nil_job)
	}

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

	ctx, cancel := new_cancel_context(parent)
	mut handle := &PeriodicHandle{
		parent:    parent
		ctx:       context.Context(ctx)
		cancel:    cancel
		result_ch: chan PeriodicResult{cap: 1}
		mutex:     sync.new_mutex()
	}
	spawn run_periodic_handle(mut handle, interval, f)
	return handle
}

// stop requests cooperative shutdown of the detached periodic loop.
//
// stop is idempotent and non-blocking. A running job still has to return
// naturally; wait() is responsible for observing the final result.
pub fn (mut h PeriodicHandle) stop() {
	mut parent := h.parent
	parent_err := parent.err()
	h.mutex.lock()
	if h.stopped {
		h.mutex.unlock()
		return
	}
	h.stopped = true
	h.stop_owns_cancel = parent_err is none
	should_cancel := h.stop_owns_cancel
	cancel := h.cancel
	h.mutex.unlock()
	if should_cancel {
		cancel()
	}
}

// wait blocks until the detached periodic loop exits.
//
// wait is one-shot. It returns job errors and parent cancellation errors. A
// normal stop() request is reported as successful completion.
pub fn (mut h PeriodicHandle) wait() ! {
	h.mutex.lock()
	if h.waited {
		h.mutex.unlock()
		return error(err_periodic_wait_called)
	}
	h.waited = true
	h.mutex.unlock()

	result := <-h.result_ch
	if result.err !is none {
		if result.kind == .context_error && h.is_stop_result() {
			return
		}
		return result.err
	}
}

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

fn run_periodic_handle(mut h PeriodicHandle, interval time.Duration, f JobFn) {
	mut ctx := h.ctx
	result := run_detached_periodic_loop(mut ctx, interval, f)
	h.cancel()
	h.result_ch <- result
}

fn run_detached_periodic_loop(mut ctx context.Context, interval time.Duration, f JobFn) PeriodicResult {
	done_ch := ctx.done()
	mut watch_done := true
	select {
		_ := <-done_ch {
			err := ctx.err()
			if err !is none {
				return PeriodicResult{
					kind: .context_error
					err:  err
				}
			}
			watch_done = false
		}
		else {}
	}

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

fn run_detached_periodic_iteration(mut ctx context.Context, f JobFn) PeriodicResult {
	f(mut ctx) or { return PeriodicResult{
		kind: .job_error
		err:  err
	} }
	err := ctx.err()
	if err !is none {
		return PeriodicResult{
			kind: .context_error
			err:  err
		}
	}
	return PeriodicResult{}
}

fn (mut h PeriodicHandle) is_stop_result() bool {
	h.mutex.lock()
	stop_owns_cancel := h.stop_owns_cancel
	h.mutex.unlock()
	return stop_owns_cancel
}