// SPDX-FileCopyrightText: © 2024 LEDGER SAS
// SPDX-License-Identifier: Apache-2.0
// Forked from @ledgerhq/promises/src/promise.ts

export const delay = (ms: number): Promise<void> => new Promise((f) => setTimeout(f, ms))

const defaults = {
  maxRetry: 4,
  interval: 300,
  intervalMultiplicator: 1.5,
  context: '',
  retryCondition: (_: unknown) => true,
}

export function retry<A>(f: () => Promise<A>, options?: Partial<typeof defaults>): Promise<A> {
  const { maxRetry, interval, intervalMultiplicator, retryCondition } = {
    ...defaults,
    ...options,
  }

  function rec(remainingTry: number, i: number): Promise<A> {
    const result = f()

    if (remainingTry <= 0) {
      return result
    }

    return result.catch((e) => {
      if (!retryCondition(e)) {
        throw e
      }
      return delay(i).then(() => rec(remainingTry - 1, i * intervalMultiplicator))
    })
  }

  return rec(maxRetry, interval)
}

export async function promiseAllBatched<A, B>(
  batch: number,
  items: Array<A>,
  fn: (arg0: A, arg1: number) => Promise<B>
): Promise<B[]> {
  const data = Array(items.length)
  const queue = items.map((item, index) => ({
    item,
    index,
  }))

  async function step() {
    if (queue.length === 0) return
    const first = queue.shift()
    if (first) {
      const { item, index } = first
      data[index] = await fn(item, index)
    }
    await step()
  }

  await Promise.all(
    Array(Math.min(batch, items.length))
      .fill(() => undefined)
      .map(step)
  )
  return data
}