export type BoundedDispatchResult<TJob, TResult> = {
  job: TJob;
  index: number;
  result: TResult | null;
  error?: unknown;
};

/** Drain a finite queue with a fixed number of workers. Pacing and adaptive
 * admission belong inside `execute`, at the RuntimeResourceGovernor seam. */
export async function dispatchBoundedSettled<TJob, TResult>(
  jobs: readonly TJob[],
  concurrency: number,
  execute: (job: TJob, index: number) => Promise<TResult>,
): Promise<Array<BoundedDispatchResult<TJob, TResult>>> {
  if (jobs.length === 0) return [];
  const width = Math.min(
    jobs.length,
    Math.max(1, Math.floor(Number.isFinite(concurrency) ? concurrency : 1)),
  );
  const results = new Array<BoundedDispatchResult<TJob, TResult>>(jobs.length);
  let cursor = 0;
  const workers = Array.from({ length: width }, async () => {
    while (true) {
      const index = cursor;
      cursor += 1;
      if (index >= jobs.length) return;
      const job = jobs[index]!;
      try {
        results[index] = {
          job,
          index,
          result: await execute(job, index),
        };
      } catch (error) {
        results[index] = { job, index, result: null, error };
      }
    }
  });
  await Promise.all(workers);
  return results;
}

export async function dispatchBounded<TJob, TResult>(
  jobs: readonly TJob[],
  concurrency: number,
  execute: (job: TJob, index: number) => Promise<TResult>,
): Promise<TResult[]> {
  const settled = await dispatchBoundedSettled(jobs, concurrency, execute);
  const failed = settled.find((entry) => entry.error !== undefined);
  if (failed) throw failed.error;
  return settled.map((entry) => entry.result as TResult);
}