import type {Arg0, Ret, AsFlatList, Fn} from './defs';

export = gen;

/**
 * Returns a wrapped identity function. Rarely used.
 */
declare function gen(): (arg: unknown) => AsyncGenerator<unknown, void, unknown>;
/**
 * Returns a function that applies the given functions in sequence wrapping them as
 * an asynchronous generator.
 * @param fns functions to be wrapped
 * @returns an asynchronous generator
 */
declare function gen<L extends readonly unknown[]>(
  ...fns: gen.FnList<Arg0<L>, L>
): AsFlatList<L> extends readonly [Fn, ...Fn[]]
  ? (arg: Arg0<L>) => AsyncGenerator<Ret<L>, void, unknown>
  : (arg: unknown) => AsyncGenerator<unknown, void, unknown>;

declare namespace gen {
  /**
   * Returns a type, which was expected from a list item.
   * It is used to highlight mismatches between argument types and return types in a list.
   */
  type FnItem<I, F> = F extends readonly [infer F1, ...infer R]
    ? F1 extends null | undefined
      ? readonly [F1, ...FnList<I, R>]
      : readonly [FnItem<I, F1>, ...FnList<Ret<F1, I>, R>]
    : F extends readonly unknown[]
      ? readonly [FnItem<I, any>]
      : F extends Fn
        ? I extends Arg0<F>
          ? F
          : (arg: I, ...rest: readonly unknown[]) => ReturnType<F>
        : F extends null | undefined
          ? F
          : never;

  /**
   * Replicates a tuple verifying the types of the list items so arguments match returns.
   * The replicated tuple is used to highlight mismatches between list items.
   */
  type FnList<I, L> = L extends readonly [infer F1, ...infer R]
    ? F1 extends null | undefined
      ? readonly [F1, ...FnList<I, R>]
      : readonly [FnItem<I, F1>, ...FnList<Ret<F1, I>, R>]
    : L;
}