import type { List } from ".";
// @ts-ignore - Only used in doc comments
import type { Filter } from "./Filter";
// @ts-ignore - Only used in doc comments
import type FilterFn from "./Filter";
import type { Args, Call1W, Fn1, GenericFn, GenericResolver, Param0 } from "../HKT";

type _RejectMutableList<Pred extends Fn1<never, boolean>, TS extends List> =
  number extends TS["length"] ? TS
  : TS extends [infer Head, ...infer Tail] ?
    Call1W<Pred, Head> extends true ?
      _RejectMutableList<Pred, Tail>
    : [Head, ..._RejectMutableList<Pred, Tail>]
  : [];
type _RejectImmutableList<Pred extends Fn1<never, boolean>, TS extends List> =
  number extends TS["length"] ? TS
  : TS extends readonly [infer Head, ...infer Tail] ?
    Call1W<Pred, Head> extends true ?
      _RejectImmutableList<Pred, Tail>
    : readonly [Head, ..._RejectImmutableList<Pred, Tail>]
  : readonly [];

/**
 * Keep elements of a {@link List} (i.e., fixed-length tuple) that do not satisfy a predicate.
 *
 * Sig: `<T>(pred: (x: T => boolean), xs: List<T>) => List<T>`
 *
 * @see {@link Filter} for the opposite.
 */
export type Reject<Pred extends Fn1<never, boolean>, TS extends List> =
  TS extends unknown[] ? _RejectMutableList<Pred, TS> : _RejectImmutableList<Pred, TS>;

interface Resolver extends GenericResolver<[Fn1<never, boolean>, List], List> {
  on1_: ([pred]: Args<this>) => [[List<Param0<typeof pred>>], List<Param0<typeof pred>>];
  on_1: ([, xs]: Args<this>) => [[Fn1<(typeof xs)[number], boolean>], List<(typeof xs)[number]>];
  on11: ([pred, xs]: Args<this>) => [[], List<(typeof xs)[number]>];
}

/**
 * [Fn] Keep elements of a {@link List} (i.e., fixed-length tuple) that do not satisfy a predicate.
 *
 * Sig: `<T>(pred: (x: T => boolean), xs: List<T>) => List<T>`
 *
 * @see {@link FilterFn} for the opposite.
 */
export default interface RejectFn extends GenericFn<Resolver> {
  def: ([pred, xs]: Args<this>) => Reject<typeof pred, typeof xs>;
}