export const REMOTE_COMPLETION_GRACE_MS = 120_000;

export interface RemoteCompletionTimer {
  setTimeout(callback: () => void, delayMs: number): unknown;
  clearTimeout(handle: unknown): void;
}

export const systemRemoteCompletionTimer: RemoteCompletionTimer = {
  setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
  clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
};

const REMOTE_GRACE_EXPIRED = Symbol("remote grace expired");

export async function waitForRemoteCompletion<T>(params: {
  promise: Promise<T | undefined>;
  controller: AbortController;
  timer?: RemoteCompletionTimer;
}): Promise<T | undefined> {
  const timer = params.timer ?? systemRemoteCompletionTimer;
  let timeoutHandle: unknown;
  const expiration = new Promise<typeof REMOTE_GRACE_EXPIRED>((resolve) => {
    timeoutHandle = timer.setTimeout(() => {
      resolve(REMOTE_GRACE_EXPIRED);
      params.controller.abort(new DOMException(
        "Remote compaction completion grace period expired.",
        "TimeoutError",
      ));
    }, REMOTE_COMPLETION_GRACE_MS);
  });

  try {
    const outcome = await Promise.race([params.promise, expiration]);
    if (outcome !== REMOTE_GRACE_EXPIRED) return outcome;

    // The timeout aborts the actual remote workflow. Wait for its public promise
    // to settle so no rejected or still-running fetch is left behind.
    await params.promise;
    return undefined;
  } finally {
    if (timeoutHandle !== undefined) timer.clearTimeout(timeoutHandle);
  }
}