import type { ResponsesSendBudget } from "./request-send-budget";

/** Dispose the failed exchange before projecting a refresh refusal or rethrowing its original error. */
export function createAutoPauseRefreshErrorMapper(
  response: Response,
  upstream: { abort(): void },
  cleanup: () => void,
  refusal: (error: unknown) => Response | undefined,
  cancelled: () => boolean,
  cancelledResponse: () => Response,
): (error: unknown) => { failed: Response } | undefined {
  return error => {
    const clientCancelled = cancelled();
    try { void response.body?.cancel().catch(() => {}); } catch { /* closed */ }
    cleanup();
    upstream.abort();
    const failed = clientCancelled ? cancelledResponse() : refusal(error);
    return failed ? { failed } : undefined;
  };
}

const moves = new WeakMap<object, number>();
/** One same-provider credential move, funded by the existing recovery owner. */
export async function recoverAutoPausedAccount<T>(options: {
  requestKey: object;
  remaining?: number;
  reserve: ResponsesSendBudget["reserveCredentialHop"];
  refresh: () => Promise<boolean>;
  /** Map a known refresh refusal; unknown errors still propagate after unused-hop cleanup. */
  mapRefreshError?: (error: unknown) => T | undefined;
  refetch: () => Promise<T>;
  setPermit: (permit: ResponsesSendBudget["pendingHopPermit"]) => void;
}): Promise<T | undefined> {
  const count = moves.get(options.requestKey) ?? 0;
  if (count >= 3 || options.remaining !== undefined && options.remaining <= 0) return;
  const hop = options.reserve("auth-recovery", "account-auto-pause", true);
  if (!hop.allowed) return;
  try {
    let refreshed: boolean;
    try { refreshed = await options.refresh(); }
    catch (error) {
      const failure = options.mapRefreshError?.(error);
      if (failure !== undefined) return failure;
      throw error;
    }
    if (!refreshed) return;
    moves.set(options.requestKey, count + 1);
    options.setPermit(hop.permit);
    return await options.refetch();
  } finally {
    options.setPermit(undefined);
    hop.permit?.release();
  }
}
