import type { List } from ".";
import type { Args, Call2W, Fn2, GenericFn, GenericResolver, Param0, Param1, Return } from "../HKT";
import type { Broaden } from "../helpers";

/**
 * Apply a binary function to each element of a {@link List} (i.e., fixed-length tuple), starting
 * from the **left**. The result of the previous application is passed as the first argument to the
 * next application.
 *
 * The **L** suffix stands for “**L**eft”.
 *
 * Sig: `<T, U>(f: (acc: U, x: T) => U, init: U, xs: List<T>) => U`
 */
export type FoldL<F extends Fn2, I, TS extends List> =
  number extends TS["length"] ? Return<F>
  : TS extends readonly [...infer Init, infer Last] ?
    FoldL<F, I, Init> extends infer R ?
      Call2W<F, R, Last>
    : never
  : I;

interface Resolver extends GenericResolver<[Fn2, unknown, List], unknown> {
  on1__: ([f]: Args<this>) => [
    [Param0<typeof f> | Return<typeof f>, List<Param1<typeof f>>],
    Param0<typeof f> | Return<typeof f>,
  ];
  on_1_: ([, i]: Args<this>) => [
    [Fn2<Broaden<typeof i>, never, Broaden<typeof i>>, List],
    Broaden<typeof i>,
  ];
  on__1: ([, , xs]: Args<this>) => [[Fn2<never, Broaden<(typeof xs)[number]>>, unknown], unknown];
  on11_: ([f, i]: Args<this>) => [[List<Param1<typeof f>>], Param0<typeof f> | Return<typeof f>];
  on1_1: ([f, , xs]: Args<this>) => [
    [Param0<typeof f> | Return<typeof f>],
    Param0<typeof f> | Return<typeof f>,
  ];
  on_11: ([, i, xs]: Args<this>) => [
    [Fn2<Broaden<typeof i>, (typeof xs)[number], Broaden<typeof i>>],
    Broaden<typeof i>,
  ];
  on111: ([f, i, xs]: Args<this>) => [[], Param0<typeof f> | Return<typeof f>];
}

/**
 * [Fn] Apply a binary function to each element of a {@link List} (i.e., fixed-length tuple),
 * starting from the **left**. The result of the previous application is passed as the first
 * argument to the next application.
 *
 * The **L** suffix stands for “**L**eft”.
 *
 * Sig: `<T, U>(f: (acc: U, x: T) => U, init: U, xs: List<T>) => U`
 */
export default interface FoldLFn extends GenericFn<Resolver> {
  def: ([f, i, xs]: Args<this>) => FoldL<typeof f, typeof i, typeof xs>;
}