import { Fee, FeeOption, FeeType, Fees } from './types'

export function singleFee(feeType: FeeType, amount: Fee): Fees {
  return Object.values(FeeOption).reduce<Partial<Fees>>((a, x) => ((a[x] = amount), a), {
    type: feeType,
  }) as Fees
}

export function standardFees(feeType: FeeType, amount: Fee): Fees {
  return {
    ...singleFee(feeType, amount),
    [FeeOption.Average]: amount.times(0.5),
    [FeeOption.Fastest]: amount.times(5.0),
  }
}

export function calcFees<T, U extends unknown[]>(
  feeRates: Record<FeeOption, T>,
  calcFee: (feeRate: T, ...args: U) => Fee,
  ...args: U
): Fees {
  return (Object.entries(feeRates) as Array<[FeeOption, T]>)
    .map(([k, v]) => [k, calcFee(v, ...args)] as const)
    .reduce<Partial<Fees>>((a, [k, v]) => ((a[k] = v), a), { type: FeeType.PerByte }) as Fees
}

export async function calcFeesAsync<T, U extends unknown[]>(
  feeRates: Record<FeeOption, T>,
  calcFee: (feeRate: T, ...args: U) => Fee,
  ...args: U
): Promise<Fees> {
  return (
    await Promise.all(
      (Object.entries(feeRates) as Array<[FeeOption, T]>).map(
        async ([k, v]) => [k, await calcFee(v, ...args)] as const,
      ),
    )
  ).reduce<Partial<Fees>>((a, [k, v]) => ((a[k] = v), a), { type: FeeType.PerByte }) as Fees
}