module executor

import context
import sync

// run_sync runs f on the owner thread and waits until it finishes.
//
// Calls from the active owner pump execute inline, outside executor mutexes, to
// avoid deadlock. Inline calls still require open admission; an inline error is
// stored as the executor's first job error even if the outer callback catches it.
// That inline execution is outside FIFO queue ordering.
pub fn (mut e Executor) run_sync(f JobFn) ! {
    if f == unsafe { nil } {
        return error(err_nil_job)
    }
    thread_id := sync.thread_id()
    e.mutex.lock()
    is_owner := e.owner_active && e.owner_thread_id == thread_id
    accepting := e.accepting
    e.mutex.unlock()
    if is_owner {
        if !accepting {
            return error(err_executor_closed)
        }
        f() or {
            e.set_first_error(err)
            return err
        }
        return
    }

    result_ch := chan ExecutorJobResult{cap: 1}
    job := ExecutorJob{
        f:            f
        result_ch:    result_ch
        has_result:   true
        report_error: true
    }
    e.enqueue_job_with_context(context.background(), job)!
    result := <-result_ch
    if result.err !is none {
        return result.err
    }
}