// ============================================================================
// Helpers
// ============================================================================

type InternalTupleBuildArray<
  N extends number,
  Acc extends readonly unknown[] = [],
> = Acc["length"] extends N ? Acc : InternalTupleBuildArray<N, [...Acc, unknown]>
/**
 * @description Build a tuple of length N with unknown elements.
 *
 * @example
 *   ```
 *   // Expect: [unknown, unknown]
 *   type Example1 = TupleLengthN<2>
 *   // Expect: []
 *   type Example2 = TupleLengthN<0>
 *   ```
 */
export type TupleLengthN<N extends number> = InternalTupleBuildArray<N>

// ============================================================================
// Primitives
// ============================================================================

/**
 * @description Get an empty tuple type.
 *
 * @example
 *   ```
 *   // Expect: []
 *   type Example1 = TupleEmpty
 *   // Expect: true
 *   type Example2 = TupleIsEmpty<TupleEmpty>
 *   ```
 */
export type TupleEmpty = []

/**
 * @description Build a single-element tuple.
 *
 * @example
 *   ```
 *   // Expect: [number]
 *   type Example1 = TupleSingleton<number>
 *   // Expect: [string]
 *   type Example2 = TupleSingleton<'a'>
 *   ```
 */
export type TupleSingleton<T> = [T]

/**
 * @description Build a two-element tuple.
 *
 * @example
 *   ```
 *   // Expect: [number, string]
 *   type Example1 = TuplePair<number, string>
 *   // Expect: [boolean, boolean]
 *   type Example2 = TuplePair<boolean, boolean>
 *   ```
 */
export type TuplePair<T, U> = [T, U]

/**
 * @description Build a three-element tuple.
 *
 * @example
 *   ```
 *   // Expect: [number, string, boolean]
 *   type Example1 = TupleTriple<number, string, boolean>
 *   // Expect: [1, 2, 3]
 *   type Example2 = TupleTriple<1, 2, 3>
 *   ```
 */
export type TupleTriple<T, U, V> = [T, U, V]

/**
 * @description Build a four-element tuple.
 *
 * @example
 *   ```
 *   // Expect: [number, string, boolean, null]
 *   type Example1 = TupleQuad<number, string, boolean, null>
 *   // Expect: [1, 2, 3, 4]
 *   type Example2 = TupleQuad<1, 2, 3, 4>
 *   ```
 */
export type TupleQuad<T, U, V, W> = [T, U, V, W]

/**
 * @description Build a five-element tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3, 4, 5]
 *   type Example1 = TupleQuint<1, 2, 3, 4, 5>
 *   // Expect: [string, string, string, string, string]
 *   type Example2 = TupleQuint<string, string, string, string, string>
 *   ```
 */
export type TupleQuint<T, U, V, W, X> = [T, U, V, W, X]

/**
 * @description Build a tuple of length 2.
 *
 * @example
 *   ```
 *   // Expect: [unknown, unknown]
 *   type Example1 = TupleLength2
 *   // Expect: 2
 *   type Example2 = TupleLength<TupleLength2>
 *   ```
 */
export type TupleLength2 = [unknown, unknown]

/**
 * @description Build a tuple of length 3.
 *
 * @example
 *   ```
 *   // Expect: [unknown, unknown, unknown]
 *   type Example1 = TupleLength3
 *   // Expect: 3
 *   type Example2 = TupleLength<TupleLength3>
 *   ```
 */
export type TupleLength3 = [unknown, unknown, unknown]

/**
 * @description Build a tuple of length 4.
 *
 * @example
 *   ```
 *   // Expect: [unknown, unknown, unknown, unknown]
 *   type Example1 = TupleLength4
 *   // Expect: 4
 *   type Example2 = TupleLength<TupleLength4>
 *   ```
 */
export type TupleLength4 = [unknown, unknown, unknown, unknown]

/**
 * @description Build a tuple of length 5.
 *
 * @example
 *   ```
 *   // Expect: [unknown, unknown, unknown, unknown, unknown]
 *   type Example1 = TupleLength5
 *   // Expect: 5
 *   type Example2 = TupleLength<TupleLength5>
 *   ```
 */
export type TupleLength5 = [unknown, unknown, unknown, unknown, unknown]

/**
 * @description Build a tuple of length 6.
 *
 * @example
 *   ```
 *   // Expect: [unknown, unknown, unknown, unknown, unknown, unknown]
 *   type Example1 = TupleLength6
 *   // Expect: 6
 *   type Example2 = TupleLength<TupleLength6>
 *   ```
 */
export type TupleLength6 = [unknown, unknown, unknown, unknown, unknown, unknown]

/**
 * @description Build a tuple of length 7.
 *
 * @example
 *   ```
 *   // Expect: [unknown, unknown, unknown, unknown, unknown, unknown, unknown]
 *   type Example1 = TupleLength7
 *   // Expect: 7
 *   type Example2 = TupleLength<TupleLength7>
 *   ```
 */
export type TupleLength7 = [unknown, unknown, unknown, unknown, unknown, unknown, unknown]

// ============================================================================
// Validation
// ============================================================================

/**
 * @description Check if a type is a tuple (not a generic array).
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsTuple<[number, string]>
 *   // Expect: false
 *   type Example2 = TupleIsTuple<string[]>
 *   ```
 */
export type TupleIsTuple<T extends readonly unknown[]> = number extends T["length"] ? false : true

/**
 * @description Check if a tuple is empty.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsEmpty<[]>
 *   // Expect: false
 *   type Example2 = TupleIsEmpty<[number]>
 *   ```
 */
export type TupleIsEmpty<T extends readonly unknown[]> = T extends [] ? true : false

/**
 * @description Check if a tuple is non-empty.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsNonEmpty<[number]>
 *   // Expect: false
 *   type Example2 = TupleIsNonEmpty<[]>
 *   ```
 */
export type TupleIsNonEmpty<T extends readonly unknown[]> = T extends [] ? false : true

/**
 * @description Check if a tuple is readonly.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsReadonly<readonly [number]>
 *   // Expect: false
 *   type Example2 = TupleIsReadonly<[number]>
 *   ```
 */
export type TupleIsReadonly<T extends readonly unknown[]> = T extends unknown[] ? false : true

/**
 * @description Check if a tuple has fixed length.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsFixedLength<[number, string]>
 *   // Expect: false
 *   type Example2 = TupleIsFixedLength<number[]>
 *   ```
 */
export type TupleIsFixedLength<T extends readonly unknown[]> = TupleIsTuple<T>

/**
 * @description Check if a tuple type is never.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsNever<never>
 *   // Expect: false
 *   type Example2 = TupleIsNever<[]>
 *   ```
 */
export type TupleIsNever<T> = [T] extends [never] ? true : false

type InternalIsAny<T> = 0 extends 1 & T ? true : false
/**
 * @description Check if a tuple type is any.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsAny<any>
 *   // Expect: false
 *   type Example2 = TupleIsAny<[]>
 *   ```
 */
export type TupleIsAny<T> = InternalIsAny<T>

type InternalIsUnknown<T> =
  InternalIsAny<T> extends true
    ? false
    : unknown extends T
      ? T extends unknown
        ? true
        : false
      : false
/**
 * @description Check if a tuple type is unknown.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsUnknown<unknown>
 *   // Expect: false
 *   type Example2 = TupleIsUnknown<[]>
 *   ```
 */
export type TupleIsUnknown<T> = InternalIsUnknown<T>

type InternalIsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : false
/**
 * @description Check if a tuple type is a union.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsUnion<[number] | [string]>
 *   // Expect: false
 *   type Example2 = TupleIsUnion<[number]>
 *   ```
 */
export type TupleIsUnion<T> = InternalIsUnion<T>

/**
 * @description Check if a type is array-like.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsArrayLike<[number]>
 *   // Expect: false
 *   type Example2 = TupleIsArrayLike<number>
 *   ```
 */
export type TupleIsArrayLike<T> = T extends readonly unknown[] ? true : false

/**
 * @description Check if a tuple contains a never element.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleHasNeverElement<[never, number]>
 *   // Expect: false
 *   type Example2 = TupleHasNeverElement<[number, string]>
 *   ```
 */
export type TupleHasNeverElement<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? [First] extends [never]
    ? true
    : TupleHasNeverElement<Rest>
  : false

/**
 * @description Check if all tuple elements are optional (include undefined).
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsAllUndefinedable<[number | undefined, string | undefined]>
 *   // Expect: false
 *   type Example2 = TupleIsAllUndefinedable<[number, string | undefined]>
 *   ```
 */
export type TupleIsAllUndefinedable<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? undefined extends First
    ? TupleIsAllUndefinedable<Rest>
    : false
  : true

/**
 * @description Check if all tuple elements are required (exclude undefined).
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsAllNonUndefinedable<[number, string]>
 *   // Expect: false
 *   type Example2 = TupleIsAllNonUndefinedable<[number | undefined, string]>
 *   ```
 */
export type TupleIsAllNonUndefinedable<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? undefined extends First
    ? false
    : TupleIsAllNonUndefinedable<Rest>
  : true

/**
 * @description Check if all tuple elements are the same type.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsHomogeneous<[number, number, number]>
 *   // Expect: false
 *   type Example2 = TupleIsHomogeneous<[number, string]>
 *   ```
 */
export type TupleIsHomogeneous<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? TupleIsEqual<Rest, InternalTupleRepeat<First, Rest["length"]>>
  : true

/**
 * @description Check if all tuple elements are distinct.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsDistinct<[1, 2, 3]>
 *   // Expect: false
 *   type Example2 = TupleIsDistinct<[1, 2, 1]>
 *   ```
 */
export type TupleIsDistinct<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? TupleIncludes<Rest, First> extends true
    ? false
    : TupleIsDistinct<Rest>
  : true

// ============================================================================
// Comparison
// ============================================================================

type InternalIsEqual<A, B> =
  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false
/**
 * @description Check if two tuples are element-wise equal.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsEqual<[1, 2], [1, 2]>
 *   // Expect: false
 *   type Example2 = TupleIsEqual<[1, 2], [2, 1]>
 *   ```
 */
export type TupleIsEqual<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = A extends readonly [infer FirstA, ...infer RestA]
  ? B extends readonly [infer FirstB, ...infer RestB]
    ? InternalIsEqual<FirstA, FirstB> extends true
      ? TupleIsEqual<RestA, RestB>
      : false
    : false
  : B extends []
    ? true
    : false

/**
 * @description Check if a tuple starts with a prefix tuple.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleStartsWith<[1, 2, 3], [1, 2]>
 *   // Expect: false
 *   type Example2 = TupleStartsWith<[1, 2, 3], [2, 3]>
 *   ```
 */
export type TupleStartsWith<
  T extends readonly unknown[],
  P extends readonly unknown[],
> = P extends []
  ? true
  : T extends readonly [infer FirstT, ...infer RestT]
    ? P extends readonly [infer FirstP, ...infer RestP]
      ? InternalIsEqual<FirstT, FirstP> extends true
        ? TupleStartsWith<RestT, RestP>
        : false
      : false
    : false

/**
 * @description Check if a tuple ends with a suffix tuple.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleEndsWith<[1, 2, 3], [2, 3]>
 *   // Expect: false
 *   type Example2 = TupleEndsWith<[1, 2, 3], [1, 3]>
 *   ```
 */
export type TupleEndsWith<
  T extends readonly unknown[],
  S extends readonly unknown[],
> = TupleStartsWith<TupleReverse<T>, TupleReverse<S>>

/**
 * @description Check if a tuple includes a value.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIncludes<[1, 2, 3], 2>
 *   // Expect: false
 *   type Example2 = TupleIncludes<[1, 2, 3], 4>
 *   ```
 */
export type TupleIncludes<T extends readonly unknown[], U> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? InternalIsEqual<First, U> extends true
    ? true
    : TupleIncludes<Rest, U>
  : false

type InternalTupleCompareHelper<A extends number, B extends number> =
  InternalTupleBuildArray<A> extends InternalTupleBuildArray<B>
    ? 0
    : InternalTupleBuildArray<A> extends [...InternalTupleBuildArray<B>, ...infer _]
      ? 1
      : -1
/**
 * @description Check if two tuples have the same length.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleSameLength<[1, 2], ['a', 'b']>
 *   // Expect: false
 *   type Example2 = TupleSameLength<[1], ['a', 'b']>
 *   ```
 */
export type TupleSameLength<A extends readonly unknown[], B extends readonly unknown[]> =
  InternalTupleCompareHelper<A["length"], B["length"]> extends 0 ? true : false

/**
 * @description Alias of TupleStartsWith.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsPrefix<[1, 2, 3], [1, 2]>
 *   // Expect: false
 *   type Example2 = TupleIsPrefix<[1, 2, 3], [2, 3]>
 *   ```
 */
export type TupleIsPrefix<
  T extends readonly unknown[],
  P extends readonly unknown[],
> = TupleStartsWith<T, P>

/**
 * @description Alias of TupleEndsWith.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsSuffix<[1, 2, 3], [2, 3]>
 *   // Expect: false
 *   type Example2 = TupleIsSuffix<[1, 2, 3], [1, 3]>
 *   ```
 */
export type TupleIsSuffix<
  T extends readonly unknown[],
  S extends readonly unknown[],
> = TupleEndsWith<T, S>

/**
 * @description Check if every element in A is included in B.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsSubset<[1, 2], [1, 2, 3]>
 *   // Expect: false
 *   type Example2 = TupleIsSubset<[1, 4], [1, 2, 3]>
 *   ```
 */
export type TupleIsSubset<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = A extends readonly [infer First, ...infer Rest]
  ? TupleIncludes<B, First> extends true
    ? TupleIsSubset<Rest, B>
    : false
  : true

/**
 * @description Check if every element in B is included in A.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsSuperset<[1, 2, 3], [1, 2]>
 *   // Expect: false
 *   type Example2 = TupleIsSuperset<[1, 2], [1, 3]>
 *   ```
 */
export type TupleIsSuperset<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = TupleIsSubset<B, A>

/**
 * @description Compare tuple lengths and return -1, 0, or 1.
 *
 * @example
 *   ```
 *   // Expect: 0
 *   type Example1 = TupleCompareLength<[1, 2], ['a', 'b']>
 *   // Expect: -1
 *   type Example2 = TupleCompareLength<[1], ['a', 'b']>
 *   ```
 */
export type TupleCompareLength<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = InternalTupleCompareHelper<A["length"], B["length"]>

/**
 * @description Check if two tuple types are strictly equal.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsStrictEqual<[1, 2], [1, 2]>
 *   // Expect: false
 *   type Example2 = TupleIsStrictEqual<[1, 2], [2, 1]>
 *   ```
 */
export type TupleIsStrictEqual<A, B> = InternalIsEqual<A, B>

/**
 * @description Deeply compare two tuples, recursing into nested tuples.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleIsEqualDeep<[[1], [2]], [[1], [2]]>
 *   // Expect: false
 *   type Example2 = TupleIsEqualDeep<[[1], [2]], [[2], [1]]>
 *   ```
 */
export type TupleIsEqualDeep<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = A extends readonly [infer FirstA, ...infer RestA]
  ? B extends readonly [infer FirstB, ...infer RestB]
    ? FirstA extends readonly unknown[]
      ? FirstB extends readonly unknown[]
        ? TupleIsEqualDeep<FirstA, FirstB> extends true
          ? TupleIsEqualDeep<RestA, RestB>
          : false
        : false
      : InternalIsEqual<FirstA, FirstB> extends true
        ? TupleIsEqualDeep<RestA, RestB>
        : false
    : false
  : B extends []
    ? true
    : false

/**
 * @description Compare tuples lexicographically, returning -1, 0, or 1.
 *
 * @example
 *   ```
 *   // Expect: 0
 *   type Example1 = TupleCompareLexicographic<[1, 2], [1, 2]>
 *   // Expect: -1 | 1
 *   type Example2 = TupleCompareLexicographic<[1, 2], [1, 3]>
 *   ```
 */
export type TupleCompareLexicographic<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = A extends readonly [infer FirstA, ...infer RestA]
  ? B extends readonly [infer FirstB, ...infer RestB]
    ? InternalIsEqual<FirstA, FirstB> extends true
      ? TupleCompareLexicographic<RestA, RestB>
      : -1 | 1
    : 1
  : B extends []
    ? 0
    : -1

/**
 * @description Check if two tuples are equal ignoring element order.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleEqualsIgnoringOrder<[1, 2], [2, 1]>
 *   // Expect: false
 *   type Example2 = TupleEqualsIgnoringOrder<[1, 2], [1, 2, 3]>
 *   ```
 */
export type TupleEqualsIgnoringOrder<A extends readonly unknown[], B extends readonly unknown[]> =
  TupleSameLength<A, B> extends true
    ? TupleIsSubset<TupleUnique<A>, TupleUnique<B>> extends true
      ? TupleIsSubset<TupleUnique<B>, TupleUnique<A>>
      : false
    : false

/**
 * @description Alias of TupleIsSuperset.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleContainsAll<[1, 2, 3], [1, 2]>
 *   // Expect: false
 *   type Example2 = TupleContainsAll<[1, 2], [1, 3]>
 *   ```
 */
export type TupleContainsAll<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = TupleIsSuperset<A, B>

// ============================================================================
// Query
// ============================================================================

type InternalTupleIndexCounter<
  T extends readonly unknown[],
  U,
  Count extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? InternalIsEqual<First, U> extends true
    ? Count["length"]
    : InternalTupleIndexCounter<Rest, U, [...Count, unknown]>
  : -1
/**
 * @description Get the length of a tuple.
 *
 * @example
 *   ```
 *   // Expect: 3
 *   type Example1 = TupleLength<[1, 2, 3]>
 *   // Expect: 0
 *   type Example2 = TupleLength<[]>
 *   ```
 */
export type TupleLength<T extends readonly unknown[]> = T["length"]

/**
 * @description Get the first index of a value in a tuple.
 *
 * @example
 *   ```
 *   // Expect: 1
 *   type Example1 = TupleIndexOf<[1, 2, 3], 2>
 *   // Expect: -1
 *   type Example2 = TupleIndexOf<[1, 2, 3], 4>
 *   ```
 */
export type TupleIndexOf<T extends readonly unknown[], U> = InternalTupleIndexCounter<T, U>

type InternalTupleLastIndexCounter<
  T extends readonly unknown[],
  U,
  Count extends readonly unknown[] = [],
  Last extends number = -1,
> = T extends readonly [infer First, ...infer Rest]
  ? InternalTupleLastIndexCounter<
      Rest,
      U,
      [...Count, unknown],
      InternalIsEqual<First, U> extends true ? Count["length"] : Last
    >
  : Last
/**
 * @description Get the last index of a value in a tuple.
 *
 * @example
 *   ```
 *   // Expect: 2
 *   type Example1 = TupleLastIndexOf<[1, 2, 1], 1>
 *   // Expect: -1
 *   type Example2 = TupleLastIndexOf<[1, 2, 3], 4>
 *   ```
 */
export type TupleLastIndexOf<T extends readonly unknown[], U> = InternalTupleLastIndexCounter<T, U>

/**
 * @description Count occurrences of a value in a tuple.
 *
 * @example
 *   ```
 *   // Expect: 2
 *   type Example1 = TupleCount<[1, 2, 1], 1>
 *   // Expect: 0
 *   type Example2 = TupleCount<[1, 2, 3], 4>
 *   ```
 */
export type TupleCount<
  T extends readonly unknown[],
  U,
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? InternalIsEqual<First, U> extends true
    ? TupleCount<Rest, U, [...Acc, unknown]>
    : TupleCount<Rest, U, Acc>
  : Acc["length"]

/**
 * @description Find the first index of an element that extends a predicate type.
 *
 * @example
 *   ```
 *   // Expect: 1
 *   type Example1 = TupleFindIndex<[1, 'a', true], string>
 *   // Expect: -1
 *   type Example2 = TupleFindIndex<[1, 2], string>
 *   ```
 */
export type TupleFindIndex<
  T extends readonly unknown[],
  P,
  Count extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? First extends P
    ? Count["length"]
    : TupleFindIndex<Rest, P, [...Count, unknown]>
  : -1

/**
 * @description Get the head index (0 for non-empty tuples).
 *
 * @example
 *   ```
 *   // Expect: 0
 *   type Example1 = TupleHeadIndex<[1, 2]>
 *   // Expect: never
 *   type Example2 = TupleHeadIndex<[]>
 *   ```
 */
export type TupleHeadIndex<T extends readonly unknown[]> = T extends [] ? never : 0

/**
 * @description Get the last index of a tuple.
 *
 * @example
 *   ```
 *   // Expect: 2
 *   type Example1 = TupleLastIndex<[1, 2, 3]>
 *   // Expect: never
 *   type Example2 = TupleLastIndex<[]>
 *   ```
 */
export type TupleLastIndex<T extends readonly unknown[]> = T extends []
  ? never
  : InternalTupleBuildArray<T["length"]> extends [unknown, ...infer Rest]
    ? Rest["length"]
    : never

/**
 * @description Get the index of the minimum numeric literal in a tuple of numbers.
 *
 * @example
 *   ```
 *   // Expect: 1
 *   type Example1 = TupleMinIndex<[3, 1, 2]>
 *   // Expect: 0
 *   type Example2 = TupleMinIndex<[1]>
 *   ```
 */
export type TupleMinIndex<
  T extends readonly number[],
  Count extends readonly unknown[] = [],
  MinIndex extends number = 0,
  MinValue extends number | null = null,
> = T extends readonly [infer First extends number, ...infer Rest extends number[]]
  ? MinValue extends null
    ? TupleMinIndex<Rest, [...Count, unknown], Count["length"], First>
    : MinValue extends number
      ? InternalTupleBuildArray<First> extends [...InternalTupleBuildArray<MinValue>, ...infer _]
        ? TupleMinIndex<Rest, [...Count, unknown], MinIndex, MinValue>
        : TupleMinIndex<Rest, [...Count, unknown], Count["length"], First>
      : MinIndex
  : MinIndex

/**
 * @description Get the index of the maximum numeric literal in a tuple of numbers.
 *
 * @example
 *   ```
 *   // Expect: 0
 *   type Example1 = TupleMaxIndex<[3, 1, 2]>
 *   // Expect: 0
 *   type Example2 = TupleMaxIndex<[1]>
 *   ```
 */
export type TupleMaxIndex<
  T extends readonly number[],
  Count extends readonly unknown[] = [],
  MaxIndex extends number = 0,
  MaxValue extends number | null = null,
> = T extends readonly [infer First extends number, ...infer Rest extends number[]]
  ? MaxValue extends null
    ? TupleMaxIndex<Rest, [...Count, unknown], Count["length"], First>
    : MaxValue extends number
      ? InternalTupleBuildArray<MaxValue> extends [...InternalTupleBuildArray<First>, ...infer _]
        ? TupleMaxIndex<Rest, [...Count, unknown], MaxIndex, MaxValue>
        : TupleMaxIndex<Rest, [...Count, unknown], Count["length"], First>
      : MaxIndex
  : MaxIndex

/**
 * @description Find the first element that extends a predicate type.
 *
 * @example
 *   ```
 *   // Expect: 'a'
 *   type Example1 = TupleFind<[1, 'a', true], string>
 *   // Expect: never
 *   type Example2 = TupleFind<[1, 2], string>
 *   ```
 */
export type TupleFind<T extends readonly unknown[], P> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? First extends P
    ? First
    : TupleFind<Rest, P>
  : never

/**
 * @description Check if a tuple has duplicate elements.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = TupleHasDuplicates<[1, 2, 1]>
 *   // Expect: false
 *   type Example2 = TupleHasDuplicates<[1, 2, 3]>
 *   ```
 */
export type TupleHasDuplicates<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? TupleIncludes<Rest, First> extends true
    ? true
    : TupleHasDuplicates<Rest>
  : false

/**
 * @description Get all indices where a value appears in a tuple.
 *
 * @example
 *   ```
 *   // Expect: [0, 2]
 *   type Example1 = TupleIndicesOf<[1, 2, 1], 1>
 *   // Expect: []
 *   type Example2 = TupleIndicesOf<[1, 2, 3], 4>
 *   ```
 */
export type TupleIndicesOf<
  T extends readonly unknown[],
  U,
  Count extends readonly unknown[] = [],
  Acc extends readonly number[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? InternalIsEqual<First, U> extends true
    ? TupleIndicesOf<Rest, U, [...Count, unknown], [...Acc, Count["length"]]>
    : TupleIndicesOf<Rest, U, [...Count, unknown], Acc>
  : Acc

/**
 * @description Alias of TupleIndexOf.
 *
 * @example
 *   ```
 *   // Expect: 0
 *   type Example1 = TupleFirstIndexOf<[1, 2], 1>
 *   // Expect: -1
 *   type Example2 = TupleFirstIndexOf<[1, 2], 3>
 *   ```
 */
export type TupleFirstIndexOf<T extends readonly unknown[], U> = TupleIndexOf<T, U>

/**
 * @description Get the last index for each element in the tuple.
 *
 * @example
 *   ```
 *   // Expect: [2, 1, 2]
 *   type Example1 = TupleLastIndexOfAll<[1, 2, 1]>
 *   // Expect: []
 *   type Example2 = TupleLastIndexOfAll<[]>
 *   ```
 */
export type TupleLastIndexOfAll<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? [TupleLastIndexOf<T, First>, ...TupleLastIndexOfAll<Rest>]
  : []

type InternalTupleFindLastIndex<
  T extends readonly unknown[],
  P,
  Count extends readonly unknown[] = [],
  Last extends number = -1,
> = T extends readonly [infer First, ...infer Rest]
  ? InternalTupleFindLastIndex<
      Rest,
      P,
      [...Count, unknown],
      First extends P ? Count["length"] : Last
    >
  : Last
/**
 * @description Find the last index of an element that extends a predicate type.
 *
 * @example
 *   ```
 *   // Expect: 2
 *   type Example1 = TupleFindLastIndex<[1, 'a', 'b'], string>
 *   // Expect: -1
 *   type Example2 = TupleFindLastIndex<[1, 2], string>
 *   ```
 */
export type TupleFindLastIndex<T extends readonly unknown[], P> = InternalTupleFindLastIndex<T, P>

// ============================================================================
// Generation
// ============================================================================

type InternalAdd<A extends number, B extends number> = [
  ...InternalTupleBuildArray<A>,
  ...InternalTupleBuildArray<B>,
]["length"]

type InternalSubtract<A extends number, B extends number> =
  InternalTupleBuildArray<A> extends [...infer Rest, ...InternalTupleBuildArray<B>]
    ? Rest["length"]
    : never

type InternalTupleRepeat<
  T,
  N extends number,
  Acc extends readonly unknown[] = [],
> = Acc["length"] extends N ? Acc : InternalTupleRepeat<T, N, [...Acc, T]>

/**
 * @description Repeat an element type N times.
 *
 * @example
 *   ```
 *   // Expect: [string, string, string]
 *   type Example1 = TupleRepeat<string, 3>
 *   // Expect: []
 *   type Example2 = TupleRepeat<number, 0>
 *   ```
 */
export type TupleRepeat<T, N extends number> = InternalTupleRepeat<T, N>

/**
 * @description Create a numeric range tuple from Start to End (inclusive).
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3]
 *   type Example1 = TupleRange<1, 3>
 *   // Expect: [0]
 *   type Example2 = TupleRange<0, 0>
 *   ```
 */
export type TupleRange<
  Start extends number,
  End extends number,
  Acc extends readonly number[] = [],
  Current extends number = Start,
> =
  InternalTupleBuildArray<End> extends [...InternalTupleBuildArray<Current>, ...infer _]
    ? InternalIsEqual<Current, End> extends true
      ? [...Acc, Current]
      : TupleRange<
          Start,
          End,
          [...Acc, Current],
          InternalAdd<Current, 1> extends number ? InternalAdd<Current, 1> : never
        >
    : Acc

/**
 * @description Fill a tuple of length N with element type T.
 *
 * @example
 *   ```
 *   // Expect: [number, number]
 *   type Example1 = TupleFill<number, 2>
 *   // Expect: []
 *   type Example2 = TupleFill<string, 0>
 *   ```
 */
export type TupleFill<T, N extends number> = TupleRepeat<T, N>

/**
 * @description Build a tuple of length N from element type T.
 *
 * @example
 *   ```
 *   // Expect: [boolean, boolean]
 *   type Example1 = TupleOf<boolean, 2>
 *   // Expect: []
 *   type Example2 = TupleOf<string, 0>
 *   ```
 */
export type TupleOf<T, N extends number> = TupleRepeat<T, N>

/**
 * @description Alias of TupleOf.
 *
 * @example
 *   ```
 *   // Expect: [1, 1]
 *   type Example1 = TupleMake<1, 2>
 *   // Expect: []
 *   type Example2 = TupleMake<string, 0>
 *   ```
 */
export type TupleMake<T, N extends number> = TupleOf<T, N>

/**
 * @description Pad a tuple at the start to length N.
 *
 * @example
 *   ```
 *   // Expect: [0, 1, 2]
 *   type Example1 = TuplePadStart<[1, 2], 3, 0>
 *   // Expect: [1]
 *   type Example2 = TuplePadStart<[1], 1, 0>
 *   ```
 */
export type TuplePadStart<T extends readonly unknown[], N extends number, Fill = undefined> =
  TupleLength<T> extends N
    ? T
    : TupleLength<T> extends infer L
      ? L extends number
        ? InternalTupleBuildArray<L> extends [...InternalTupleBuildArray<N>, ...infer _]
          ? T
          : TuplePadStart<[Fill, ...T], N, Fill>
        : T
      : T

/**
 * @description Pad a tuple at the end to length N.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 0]
 *   type Example1 = TuplePadEnd<[1, 2], 3, 0>
 *   // Expect: [1]
 *   type Example2 = TuplePadEnd<[1], 1, 0>
 *   ```
 */
export type TuplePadEnd<T extends readonly unknown[], N extends number, Fill = undefined> =
  TupleLength<T> extends N
    ? T
    : TupleLength<T> extends infer L
      ? L extends number
        ? InternalTupleBuildArray<L> extends [...InternalTupleBuildArray<N>, ...infer _]
          ? T
          : TuplePadEnd<[...T, Fill], N, Fill>
        : T
      : T

type InternalInsertEach<T, P extends readonly unknown[]> = P extends readonly [
  infer First,
  ...infer Rest,
]
  ? [T, First, ...Rest] | [First, ...InternalInsertEach<T, Rest>]
  : [T]
/**
 * @description Get all permutations of a tuple as a union of tuples.
 *
 * @example
 *   ```
 *   // Expect: [1, 2] | [2, 1]
 *   type Example1 = TuplePermutations<[1, 2]>
 *   // Expect: []
 *   type Example2 = TuplePermutations<[]>
 *   ```
 */
export type TuplePermutations<T extends readonly unknown[]> = T extends []
  ? []
  : T extends readonly [infer First, ...infer Rest]
    ? TuplePermutations<Rest> extends infer Perm
      ? Perm extends readonly unknown[]
        ? InternalInsertEach<First, Perm>
        : never
      : never
    : never

/**
 * @description Get all combinations of a tuple as a union of tuples.
 *
 * @example
 *   ```
 *   // Expect: [] | [1] | [2] | [1, 2]
 *   type Example1 = TupleCombinations<[1, 2]>
 *   // Expect: []
 *   type Example2 = TupleCombinations<[]>
 *   ```
 */
export type TupleCombinations<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? TupleCombinations<Rest> extends infer Comb
    ? Comb extends readonly unknown[]
      ? Comb | [First, ...Comb]
      : never
    : never
  : []

/**
 * @description Compute the cartesian product of two tuples as a union of pairs.
 *
 * @example
 *   ```
 *   // Expect: [1, 'a'] | [1, 'b'] | [2, 'a'] | [2, 'b']
 *   type Example1 = TupleCartesian<[1, 2], ['a', 'b']>
 *   // Expect: never
 *   type Example2 = TupleCartesian<[], ['a']>
 *   ```
 */
export type TupleCartesian<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = A extends readonly [infer First, ...infer Rest]
  ? B extends readonly unknown[]
    ? B[number] extends infer Item
      ? [First, Item] | TupleCartesian<Rest, B>
      : never
    : never
  : never

/**
 * @description Get the power set of a tuple as a union of tuples.
 *
 * @example
 *   ```
 *   // Expect: [] | [1] | [2] | [1, 2]
 *   type Example1 = TuplePowerSet<[1, 2]>
 *   // Expect: []
 *   type Example2 = TuplePowerSet<[]>
 *   ```
 */
export type TuplePowerSet<T extends readonly unknown[]> = TupleCombinations<T>

/**
 * @description Intersperse a separator between tuple elements.
 *
 * @example
 *   ```
 *   // Expect: [1, 0, 2, 0, 3]
 *   type Example1 = TupleIntersperse<[1, 2, 3], 0>
 *   // Expect: []
 *   type Example2 = TupleIntersperse<[], 0>
 *   ```
 */
export type TupleIntersperse<T extends readonly unknown[], S> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? Rest extends []
    ? [First]
    : [First, S, ...TupleIntersperse<Rest, S>]
  : []

/**
 * @description Repeat each element N times.
 *
 * @example
 *   ```
 *   // Expect: [1, 1, 2, 2]
 *   type Example1 = TupleRepeatEach<[1, 2], 2>
 *   // Expect: []
 *   type Example2 = TupleRepeatEach<[], 3>
 *   ```
 */
export type TupleRepeatEach<T extends readonly unknown[], N extends number> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? [...TupleRepeat<First, N>, ...TupleRepeatEach<Rest, N>]
  : []

/**
 * @description Create a numeric range tuple from Start to End with step.
 *
 * @example
 *   ```
 *   // Expect: [1, 3, 5]
 *   type Example1 = TupleRangeStep<1, 5, 2>
 *   // Expect: [0]
 *   type Example2 = TupleRangeStep<0, 0, 1>
 *   ```
 */
export type TupleRangeStep<
  Start extends number,
  End extends number,
  Step extends number,
  Acc extends readonly number[] = [],
  Current extends number = Start,
> =
  InternalTupleBuildArray<End> extends [...InternalTupleBuildArray<Current>, ...infer _]
    ? InternalIsEqual<Current, End> extends true
      ? [...Acc, Current]
      : TupleRangeStep<
          Start,
          End,
          Step,
          [...Acc, Current],
          InternalAdd<Current, Step> extends number ? InternalAdd<Current, Step> : never
        >
    : Acc

// ============================================================================
// Extraction
// ============================================================================

/**
 * @description Extract the type of the first element in a tuple.
 *
 * @example
 *   ```
 *   // Expect: number
 *   type Example1 = TupleHead<[number, string, boolean]>
 *   // Expect: string
 *   type Example2 = TupleHead<[string]>
 *   ```
 */
export type TupleHead<T extends readonly unknown[]> = T extends readonly [infer First, ...unknown[]]
  ? First
  : never

/**
 * @description Extract the last element from a tuple.
 *
 * @example
 *   ```
 *   // Expect: boolean
 *   type Example1 = TupleLast<[number, string, boolean]>
 *   // Expect: string
 *   type Example2 = TupleLast<[string]>
 *   ```
 */
export type TupleLast<T extends readonly unknown[]> = T extends readonly [...unknown[], infer Last]
  ? Last
  : never

/**
 * @description Extract all elements except the first one from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [string, boolean]
 *   type Example1 = TupleTail<[number, string, boolean]>
 *   // Expect: []
 *   type Example2 = TupleTail<[string]>
 *   ```
 */
export type TupleTail<T extends readonly unknown[]> = T extends readonly [unknown, ...infer Rest]
  ? Rest
  : []

/**
 * @description Extract all elements except the last one from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [number, string]
 *   type Example1 = TuplePrev<[number, string, boolean]>
 *   // Expect: []
 *   type Example2 = TuplePrev<[string]>
 *   ```
 */
export type TuplePrev<T extends readonly unknown[]> = T extends readonly [...infer Rest, unknown]
  ? Rest
  : []

type InternalAt<
  T extends readonly unknown[],
  N extends number,
  Count extends readonly unknown[] = [],
> = Count["length"] extends N ? TupleHead<T> : InternalAt<TupleTail<T>, N, [...Count, unknown]>
/**
 * @description Get the element at index N in a tuple.
 *
 * @example
 *   ```
 *   // Expect: number
 *   type Example1 = TupleAt<[number, string, boolean], 0>
 *   // Expect: boolean
 *   type Example2 = TupleAt<[number, string, boolean], 2>
 *   ```
 */
export type TupleAt<T extends readonly unknown[], N extends number> = InternalAt<T, N>

/**
 * @description Take the first N elements from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 2]
 *   type Example1 = TupleTake<[1, 2, 3], 2>
 *   // Expect: []
 *   type Example2 = TupleTake<[1, 2], 0>
 *   ```
 */
export type TupleTake<
  T extends readonly unknown[],
  N extends number,
  Acc extends readonly unknown[] = [],
> = Acc["length"] extends N
  ? Acc
  : T extends readonly [infer First, ...infer Rest]
    ? TupleTake<Rest, N, [...Acc, First]>
    : Acc

/**
 * @description Take the last N elements from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [2, 3]
 *   type Example1 = TupleTakeLast<[1, 2, 3], 2>
 *   // Expect: []
 *   type Example2 = TupleTakeLast<[1, 2], 0>
 *   ```
 */
export type TupleTakeLast<T extends readonly unknown[], N extends number> = TupleReverse<
  TupleTake<TupleReverse<T>, N>
>

type InternalTupleSliceHelper<
  T extends readonly unknown[],
  Start extends number,
  End extends number,
> = TupleTake<TupleDrop<T, Start>, InternalSubtract<End, Start>>
/**
 * @description Slice a tuple from Start (inclusive) to End (exclusive).
 *
 * @example
 *   ```
 *   // Expect: [2, 3]
 *   type Example1 = TupleSlice<[1, 2, 3, 4], 1, 3>
 *   // Expect: []
 *   type Example2 = TupleSlice<[1, 2], 1, 1>
 *   ```
 */
export type TupleSlice<
  T extends readonly unknown[],
  Start extends number,
  End extends number,
> = InternalTupleSliceHelper<T, Start, End>

/**
 * @description Drop the first N elements from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [3]
 *   type Example1 = TupleDrop<[1, 2, 3], 2>
 *   // Expect: []
 *   type Example2 = TupleDrop<[1, 2], 2>
 *   ```
 */
export type TupleDrop<
  T extends readonly unknown[],
  N extends number,
  Count extends readonly unknown[] = [],
> = Count["length"] extends N
  ? T
  : T extends readonly [unknown, ...infer Rest]
    ? TupleDrop<Rest, N, [...Count, unknown]>
    : []

/**
 * @description Drop the last N elements from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1]
 *   type Example1 = TupleDropLast<[1, 2, 3], 2>
 *   // Expect: []
 *   type Example2 = TupleDropLast<[1, 2], 2>
 *   ```
 */
export type TupleDropLast<T extends readonly unknown[], N extends number> = TupleReverse<
  TupleDrop<TupleReverse<T>, N>
>

/**
 * @description Split a tuple at index N into [left, right].
 *
 * @example
 *   ```
 *   // Expect: [[1, 2], [3, 4]]
 *   type Example1 = TupleSplitAt<[1, 2, 3, 4], 2>
 *   // Expect: [[], [1]]
 *   type Example2 = TupleSplitAt<[1], 0>
 *   ```
 */
export type TupleSplitAt<T extends readonly unknown[], N extends number> = [
  TupleTake<T, N>,
  TupleDrop<T, N>,
]

/**
 * @description Pick elements by index list.
 *
 * @example
 *   ```
 *   // Expect: [1, 3]
 *   type Example1 = TuplePick<[1, 2, 3], [0, 2]>
 *   // Expect: []
 *   type Example2 = TuplePick<[1, 2], []>
 *   ```
 */
export type TuplePick<
  T extends readonly unknown[],
  I extends readonly number[],
> = I extends readonly [infer Index extends number, ...infer Rest extends number[]]
  ? [TupleAt<T, Index>, ...TuplePick<T, Rest>]
  : []

/**
 * @description Omit elements by index list.
 *
 * @example
 *   ```
 *   // Expect: [2]
 *   type Example1 = TupleOmit<[1, 2, 3], [0, 2]>
 *   // Expect: [1, 2]
 *   type Example2 = TupleOmit<[1, 2], []>
 *   ```
 */
export type TupleOmit<
  T extends readonly unknown[],
  I extends readonly number[],
  Count extends readonly unknown[] = [],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? TupleIncludes<I, Count["length"]> extends true
    ? TupleOmit<Rest, I, [...Count, unknown], Acc>
    : TupleOmit<Rest, I, [...Count, unknown], [...Acc, First]>
  : Acc

/**
 * @description Partition a tuple into [matching, rest] by predicate type.
 *
 * @example
 *   ```
 *   // Expect: [[1, 2], ['a']]
 *   type Example1 = TuplePartition<[1, 'a', 2], number>
 *   // Expect: [[], [1, 2]]
 *   type Example2 = TuplePartition<[1, 2], string>
 *   ```
 */
export type TuplePartition<
  T extends readonly unknown[],
  P,
  Matches extends readonly unknown[] = [],
  Rest extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Tail]
  ? First extends P
    ? TuplePartition<Tail, P, [...Matches, First], Rest>
    : TuplePartition<Tail, P, Matches, [...Rest, First]>
  : [Matches, Rest]

/**
 * @description Group a tuple of [key, value] pairs by key.
 *
 * @example
 *   ```
 *   // Expect: { a: [1, 3]; b: [2] }
 *   type Example1 = TupleGroupBy<[['a', 1], ['b', 2], ['a', 3]]>
 *   // Expect: {}
 *   type Example2 = TupleGroupBy<[]>
 *   ```
 */
export type TupleGroupBy<
  T extends ReadonlyArray<readonly [PropertyKey, unknown]>,
  Acc extends Record<PropertyKey, unknown[]> = Record<never, never>,
> = T extends readonly [
  infer First extends readonly [PropertyKey, unknown],
  ...infer Rest extends ReadonlyArray<readonly [PropertyKey, unknown]>,
]
  ? TupleGroupBy<
      Rest,
      {
        [K in keyof Acc | First[0]]: K extends First[0]
          ? K extends keyof Acc
            ? [...Acc[K], First[1]]
            : [First[1]]
          : K extends keyof Acc
            ? Acc[K]
            : never
      }
    >
  : Acc

/**
 * @description Create a sliding window of size N.
 *
 * @example
 *   ```
 *   // Expect: [[1, 2], [2, 3]]
 *   type Example1 = TupleWindow<[1, 2, 3], 2>
 *   // Expect: []
 *   type Example2 = TupleWindow<[1], 2>
 *   ```
 */
export type TupleWindow<T extends readonly unknown[], N extends number> =
  TupleTake<T, N> extends infer Head
    ? Head extends readonly unknown[]
      ? TupleLength<Head> extends N
        ? [Head, ...TupleWindow<TupleDrop<T, 1>, N>]
        : []
      : []
    : []

/**
 * @description Pluck a property from a tuple of objects.
 *
 * @example
 *   ```
 *   // Expect: [1, 2]
 *   type Example1 = TuplePluck<[{ id: 1 }, { id: 2 }], 'id'>
 *   // Expect: []
 *   type Example2 = TuplePluck<[], 'id'>
 *   ```
 */
export type TuplePluck<T extends readonly unknown[], K extends PropertyKey> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? [First extends Record<K, unknown> ? First[K] : never, ...TuplePluck<Rest, K>]
  : []

/**
 * @description Alias of TuplePick.
 *
 * @example
 *   ```
 *   // Expect: [1]
 *   type Example1 = TuplePickByIndex<[1, 2], [0]>
 *   // Expect: []
 *   type Example2 = TuplePickByIndex<[1, 2], []>
 *   ```
 */
export type TuplePickByIndex<T extends readonly unknown[], I extends readonly number[]> = TuplePick<
  T,
  I
>

/**
 * @description Alias of TupleOmit.
 *
 * @example
 *   ```
 *   // Expect: [2]
 *   type Example1 = TupleOmitByIndex<[1, 2], [0]>
 *   // Expect: [1, 2]
 *   type Example2 = TupleOmitByIndex<[1, 2], []>
 *   ```
 */
export type TupleOmitByIndex<T extends readonly unknown[], I extends readonly number[]> = TupleOmit<
  T,
  I
>

type InternalTupleSplitHelper<
  T extends readonly unknown[],
  Sep,
  Current extends readonly unknown[] = [],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? InternalIsEqual<First, Sep> extends true
    ? InternalTupleSplitHelper<Rest, Sep, [], [...Acc, Current]>
    : InternalTupleSplitHelper<Rest, Sep, [...Current, First], Acc>
  : [...Acc, Current]
/**
 * @description Split a tuple by a separator element.
 *
 * @example
 *   ```
 *   // Expect: [[1], [2, 3]]
 *   type Example1 = TupleSplitBy<[1, 0, 2, 3], 0>
 *   // Expect: [[]]
 *   type Example2 = TupleSplitBy<[], 0>
 *   ```
 */
export type TupleSplitBy<T extends readonly unknown[], Sep> = InternalTupleSplitHelper<T, Sep>

/**
 * @description Chunk a tuple by a separator element.
 *
 * @example
 *   ```
 *   // Expect: [[1], [2, 3]]
 *   type Example1 = TupleChunkBy<[1, 0, 2, 3], 0>
 *   // Expect: [[]]
 *   type Example2 = TupleChunkBy<[], 0>
 *   ```
 */
export type TupleChunkBy<T extends readonly unknown[], Sep> = TupleSplitBy<T, Sep>

// ============================================================================
// Manipulation
// ============================================================================

/**
 * @description Prepend an element to a tuple.
 *
 * @example
 *   ```
 *   // Expect: [number, string, boolean]
 *   type Example1 = TuplePrepend<[string, boolean], number>
 *   // Expect: [number]
 *   type Example2 = TuplePrepend<[], number>
 *   ```
 */
export type TuplePrepend<T extends readonly unknown[], E> = [E, ...T]

/**
 * @description Append an element to a tuple.
 *
 * @example
 *   ```
 *   // Expect: [string, boolean, number]
 *   type Example1 = TupleAppend<[string, boolean], number>
 *   // Expect: [number]
 *   type Example2 = TupleAppend<[], number>
 *   ```
 */
export type TupleAppend<T extends readonly unknown[], E> = [...T, E]

type InternalReverse<
  T extends readonly unknown[],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest] ? InternalReverse<Rest, [First, ...Acc]> : Acc
/**
 * @description Reverse the order of elements in a tuple.
 *
 * @example
 *   ```
 *   // Expect: [boolean, string, number]
 *   type Example1 = TupleReverse<[number, string, boolean]>
 *   // Expect: []
 *   type Example2 = TupleReverse<[]>
 *   ```
 */
export type TupleReverse<T extends readonly unknown[]> = InternalReverse<T>

/**
 * @description Concatenate two tuples.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3]
 *   type Example1 = TupleConcat<[1, 2], [3]>
 *   // Expect: [1]
 *   type Example2 = TupleConcat<[1], []>
 *   ```
 */
export type TupleConcat<A extends readonly unknown[], B extends readonly unknown[]> = [...A, ...B]

/**
 * @description Flatten a tuple by one level.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3]
 *   type Example1 = TupleFlatten<[[1, 2], [3]]>
 *   // Expect: [1, 2]
 *   type Example2 = TupleFlatten<[1, [2]]>
 *   ```
 */
export type TupleFlatten<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? First extends readonly unknown[]
    ? [...First, ...TupleFlatten<Rest>]
    : [First, ...TupleFlatten<Rest>]
  : []

/**
 * @description Prepend an element to each tuple in a tuple of tuples.
 *
 * @example
 *   ```
 *   // Expect: [[0, 1], [0, 2]]
 *   type Example1 = TuplePrependAll<[[1], [2]], 0>
 *   // Expect: []
 *   type Example2 = TuplePrependAll<[], 0>
 *   ```
 */
export type TuplePrependAll<T extends readonly unknown[][], E> = T extends readonly [
  infer First extends readonly unknown[],
  ...infer Rest extends readonly unknown[][],
]
  ? [[E, ...First], ...TuplePrependAll<Rest, E>]
  : []

/**
 * @description Append an element to each tuple in a tuple of tuples.
 *
 * @example
 *   ```
 *   // Expect: [[1, 0], [2, 0]]
 *   type Example1 = TupleAppendAll<[[1], [2]], 0>
 *   // Expect: []
 *   type Example2 = TupleAppendAll<[], 0>
 *   ```
 */
export type TupleAppendAll<T extends readonly unknown[][], E> = T extends readonly [
  infer First extends readonly unknown[],
  ...infer Rest extends readonly unknown[][],
]
  ? [[...First, E], ...TupleAppendAll<Rest, E>]
  : []

/**
 * @description Map a tuple using a mapper function type.
 *
 * @example
 *   ```
 *   // Expect: [string, string]
 *   type Example1 = TupleMap<[1, 2], (value: number) => string>
 *   // Expect: []
 *   type Example2 = TupleMap<[], (value: number) => string>
 *   ```
 */
export type TupleMap<
  T extends readonly unknown[],
  Mapper extends (value: unknown, index: number, tuple: readonly unknown[]) => unknown,
> = {
  [K in keyof T]: Mapper extends (value: T[K], index: number, tuple: T) => infer R ? R : never
}

/**
 * @description Filter a tuple by a predicate type.
 *
 * @example
 *   ```
 *   // Expect: [1, 2]
 *   type Example1 = TupleFilter<[1, 'a', 2], number>
 *   // Expect: []
 *   type Example2 = TupleFilter<[true, false], string>
 *   ```
 */
export type TupleFilter<
  T extends readonly unknown[],
  P,
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? First extends P
    ? TupleFilter<Rest, P, [...Acc, First]>
    : TupleFilter<Rest, P, Acc>
  : Acc

type InternalTupleZipHelper<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = A extends readonly [infer FirstA, ...infer RestA]
  ? B extends readonly [infer FirstB, ...infer RestB]
    ? [[FirstA, FirstB], ...InternalTupleZipHelper<RestA, RestB>]
    : []
  : []
/**
 * @description Zip two tuples into a tuple of pairs.
 *
 * @example
 *   ```
 *   // Expect: [[1, 'a'], [2, 'b']]
 *   type Example1 = TupleZip<[1, 2], ['a', 'b']>
 *   // Expect: []
 *   type Example2 = TupleZip<[], ['a']>
 *   ```
 */
export type TupleZip<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = InternalTupleZipHelper<A, B>

type InternalTupleUnzipHelper<
  T extends readonly unknown[],
  Left extends readonly unknown[] = [],
  Right extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? First extends readonly [infer L, infer R]
    ? InternalTupleUnzipHelper<Rest, [...Left, L], [...Right, R]>
    : InternalTupleUnzipHelper<Rest, Left, Right>
  : [Left, Right]
/**
 * @description Unzip a tuple of pairs into two tuples.
 *
 * @example
 *   ```
 *   // Expect: [[1, 2], ['a', 'b']]
 *   type Example1 = TupleUnzip<[[1, 'a'], [2, 'b']]>
 *   // Expect: [[], []]
 *   type Example2 = TupleUnzip<[]>
 *   ```
 */
export type TupleUnzip<T extends readonly unknown[]> = InternalTupleUnzipHelper<T>

type InternalTupleDedup<
  T extends readonly unknown[],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? TupleIncludes<Acc, First> extends true
    ? InternalTupleDedup<Rest, Acc>
    : InternalTupleDedup<Rest, [...Acc, First]>
  : Acc
/**
 * @description Remove duplicate elements from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 2]
 *   type Example1 = TupleUnique<[1, 2, 1]>
 *   // Expect: []
 *   type Example2 = TupleUnique<[]>
 *   ```
 */
export type TupleUnique<T extends readonly unknown[]> = InternalTupleDedup<T>

/**
 * @description Swap two elements by index.
 *
 * @example
 *   ```
 *   // Expect: [2, 1, 3]
 *   type Example1 = TupleSwap<[1, 2, 3], 0, 1>
 *   // Expect: [1, 2, 3]
 *   type Example2 = TupleSwap<[1, 2, 3], 0, 0>
 *   ```
 */
export type TupleSwap<
  T extends readonly unknown[],
  A extends number,
  B extends number,
  Count extends readonly unknown[] = [],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? Count["length"] extends A
    ? TupleSwap<Rest, A, B, [...Count, unknown], [...Acc, TupleAt<T, B>]>
    : Count["length"] extends B
      ? TupleSwap<Rest, A, B, [...Count, unknown], [...Acc, TupleAt<T, A>]>
      : TupleSwap<Rest, A, B, [...Count, unknown], [...Acc, First]>
  : Acc

/**
 * @description Insert a value at index N.
 *
 * @example
 *   ```
 *   // Expect: [1, 0, 2]
 *   type Example1 = TupleInsert<[1, 2], 1, 0>
 *   // Expect: [0, 1]
 *   type Example2 = TupleInsert<[1], 0, 0>
 *   ```
 */
export type TupleInsert<
  T extends readonly unknown[],
  N extends number,
  V,
  Acc extends readonly unknown[] = [],
> = Acc["length"] extends N
  ? [...Acc, V, ...T]
  : T extends readonly [infer First, ...infer Rest]
    ? TupleInsert<Rest, N, V, [...Acc, First]>
    : [...Acc, V]

/**
 * @description Remove the element at index N.
 *
 * @example
 *   ```
 *   // Expect: [1, 3]
 *   type Example1 = TupleRemoveAt<[1, 2, 3], 1>
 *   // Expect: [2]
 *   type Example2 = TupleRemoveAt<[2], 0>
 *   ```
 */
export type TupleRemoveAt<
  T extends readonly unknown[],
  N extends number,
  Count extends readonly unknown[] = [],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? Count["length"] extends N
    ? [...Acc, ...Rest]
    : TupleRemoveAt<Rest, N, [...Count, unknown], [...Acc, First]>
  : Acc

/**
 * @description Replace the element at index N.
 *
 * @example
 *   ```
 *   // Expect: [1, 0, 3]
 *   type Example1 = TupleReplaceAt<[1, 2, 3], 1, 0>
 *   // Expect: [0]
 *   type Example2 = TupleReplaceAt<[2], 0, 0>
 *   ```
 */
export type TupleReplaceAt<
  T extends readonly unknown[],
  N extends number,
  V,
  Count extends readonly unknown[] = [],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? Count["length"] extends N
    ? [...Acc, V, ...Rest]
    : TupleReplaceAt<Rest, N, V, [...Count, unknown], [...Acc, First]>
  : Acc

type InternalTupleRotateHelper<T extends readonly unknown[], N extends number> = N extends 0
  ? T
  : InternalTupleRotateHelper<TupleConcat<TupleTail<T>, [TupleHead<T>]>, InternalSubtract<N, 1>>
/**
 * @description Rotate a tuple left by N (negative rotates right).
 *
 * @example
 *   ```
 *   // Expect: [2, 3, 1]
 *   type Example1 = TupleRotate<[1, 2, 3], 1>
 *   // Expect: [3, 1, 2]
 *   type Example2 = TupleRotate<[1, 2, 3], -1>
 *   ```
 */
export type TupleRotate<
  T extends readonly unknown[],
  N extends number,
> = `${N}` extends `-${infer P extends number}`
  ? TupleRotateRight<T, P>
  : InternalTupleRotateHelper<T, N>

type InternalTupleChunkHelper<
  T extends readonly unknown[],
  N extends number,
  Current extends readonly unknown[] = [],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? Current["length"] extends N
    ? InternalTupleChunkHelper<T, N, [], [...Acc, Current]>
    : InternalTupleChunkHelper<Rest, N, [...Current, First], Acc>
  : Current extends []
    ? Acc
    : [...Acc, Current]
/**
 * @description Chunk a tuple into sub-tuples of size N.
 *
 * @example
 *   ```
 *   // Expect: [[1, 2], [3]]
 *   type Example1 = TupleChunk<[1, 2, 3], 2>
 *   // Expect: []
 *   type Example2 = TupleChunk<[], 2>
 *   ```
 */
export type TupleChunk<T extends readonly unknown[], N extends number> = InternalTupleChunkHelper<
  T,
  N
>

/**
 * @description Remove the first element of a tuple.
 *
 * @example
 *   ```
 *   // Expect: [2, 3]
 *   type Example1 = TupleShift<[1, 2, 3]>
 *   // Expect: []
 *   type Example2 = TupleShift<[1]>
 *   ```
 */
export type TupleShift<T extends readonly unknown[]> = TupleTail<T>

/**
 * @description Remove the last element of a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 2]
 *   type Example1 = TuplePop<[1, 2, 3]>
 *   // Expect: []
 *   type Example2 = TuplePop<[1]>
 *   ```
 */
export type TuplePop<T extends readonly unknown[]> = TuplePrev<T>

/**
 * @description Append a value to a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3]
 *   type Example1 = TuplePush<[1, 2], 3>
 *   // Expect: [1]
 *   type Example2 = TuplePush<[], 1>
 *   ```
 */
export type TuplePush<T extends readonly unknown[], V> = TupleAppend<T, V>

/**
 * @description Prepend a value to a tuple.
 *
 * @example
 *   ```
 *   // Expect: [0, 1, 2]
 *   type Example1 = TupleUnshift<[1, 2], 0>
 *   // Expect: [1]
 *   type Example2 = TupleUnshift<[], 1>
 *   ```
 */
export type TupleUnshift<T extends readonly unknown[], V> = TuplePrepend<T, V>

/**
 * @description Reverse a section of a tuple from Start to End (exclusive).
 *
 * @example
 *   ```
 *   // Expect: [1, 3, 2, 4]
 *   type Example1 = TupleReverseSection<[1, 2, 3, 4], 1, 3>
 *   // Expect: [1, 2]
 *   type Example2 = TupleReverseSection<[1, 2], 0, 1>
 *   ```
 */
export type TupleReverseSection<
  T extends readonly unknown[],
  Start extends number,
  End extends number,
> = TupleConcat<
  TupleTake<T, Start>,
  TupleConcat<TupleReverse<TupleSlice<T, Start, End>>, TupleDrop<T, End>>
>

/**
 * @description Shuffle a tuple (returns permutations as a union).
 *
 * @example
 *   ```
 *   // Expect: [1, 2] | [2, 1]
 *   type Example1 = TupleShuffle<[1, 2]>
 *   // Expect: []
 *   type Example2 = TupleShuffle<[]>
 *   ```
 */
export type TupleShuffle<T extends readonly unknown[]> = TuplePermutations<T>

type InternalInsertSorted<V extends number, T extends readonly number[]> = T extends readonly [
  infer First extends number,
  ...infer Rest extends number[],
]
  ? InternalTupleBuildArray<V> extends [...InternalTupleBuildArray<First>, ...infer _]
    ? [First, ...InternalInsertSorted<V, Rest>]
    : [V, First, ...Rest]
  : [V]
/**
 * @description Sort a tuple of numbers in ascending order.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3]
 *   type Example1 = TupleSort<[3, 1, 2]>
 *   // Expect: []
 *   type Example2 = TupleSort<[]>
 *   ```
 */
export type TupleSort<T extends readonly number[]> = T extends readonly [
  infer First extends number,
  ...infer Rest extends number[],
]
  ? InternalInsertSorted<First, TupleSort<Rest>>
  : []

/**
 * @description Stable sort a tuple of numbers in ascending order.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3]
 *   type Example1 = TupleStableSort<[3, 1, 2]>
 *   // Expect: []
 *   type Example2 = TupleStableSort<[]>
 *   ```
 */
export type TupleStableSort<T extends readonly number[]> = TupleSort<T>

/**
 * @description Flatten a tuple by one level.
 *
 * @example
 *   ```
 *   // Expect: [1, 2]
 *   type Example1 = TupleFlattenOnce<[[1], [2]]>
 *   // Expect: []
 *   type Example2 = TupleFlattenOnce<[]>
 *   ```
 */
export type TupleFlattenOnce<T extends readonly unknown[]> = TupleFlatten<T>

/**
 * @description Deeply flatten a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, 3]
 *   type Example1 = TupleFlattenDeep<[[1, [2]], 3]>
 *   // Expect: []
 *   type Example2 = TupleFlattenDeep<[]>
 *   ```
 */
export type TupleFlattenDeep<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? First extends readonly unknown[]
    ? [...TupleFlattenDeep<First>, ...TupleFlattenDeep<Rest>]
    : [First, ...TupleFlattenDeep<Rest>]
  : []

/**
 * @description Remove falsy values from a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 'a']
 *   type Example1 = TupleCompact<[0, 1, '', 'a', false]>
 *   // Expect: []
 *   type Example2 = TupleCompact<[]>
 *   ```
 */
export type TupleCompact<
  T extends readonly unknown[],
  Acc extends readonly unknown[] = [],
> = T extends readonly [infer First, ...infer Rest]
  ? First extends false | 0 | "" | null | undefined
    ? TupleCompact<Rest, Acc>
    : TupleCompact<Rest, [...Acc, First]>
  : Acc

/**
 * @description Get elements in A that are also in B.
 *
 * @example
 *   ```
 *   // Expect: [2]
 *   type Example1 = TupleIntersect<[1, 2, 3], [2, 4]>
 *   // Expect: []
 *   type Example2 = TupleIntersect<[1], [2]>
 *   ```
 */
export type TupleIntersect<
  A extends readonly unknown[],
  B extends readonly unknown[],
  Acc extends readonly unknown[] = [],
> = A extends readonly [infer First, ...infer Rest]
  ? TupleIncludes<B, First> extends true
    ? TupleIntersect<Rest, B, [...Acc, First]>
    : TupleIntersect<Rest, B, Acc>
  : Acc

/**
 * @description Get elements in A that are not in B.
 *
 * @example
 *   ```
 *   // Expect: [1, 3]
 *   type Example1 = TupleDifference<[1, 2, 3], [2]>
 *   // Expect: [1]
 *   type Example2 = TupleDifference<[1], [2]>
 *   ```
 */
export type TupleDifference<
  A extends readonly unknown[],
  B extends readonly unknown[],
  Acc extends readonly unknown[] = [],
> = A extends readonly [infer First, ...infer Rest]
  ? TupleIncludes<B, First> extends true
    ? TupleDifference<Rest, B, Acc>
    : TupleDifference<Rest, B, [...Acc, First]>
  : Acc

/**
 * @description Get elements that are in A or B but not both.
 *
 * @example
 *   ```
 *   // Expect: [1, 3]
 *   type Example1 = TupleSymmetricDifference<[1, 2], [2, 3]>
 *   // Expect: [1]
 *   type Example2 = TupleSymmetricDifference<[1], []>
 *   ```
 */
export type TupleSymmetricDifference<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = TupleConcat<TupleDifference<A, B>, TupleDifference<B, A>>

/**
 * @description Reverse all but the last element of a tuple.
 *
 * @example
 *   ```
 *   // Expect: [2, 1, 3]
 *   type Example1 = TupleReverseHead<[1, 2, 3]>
 *   // Expect: []
 *   type Example2 = TupleReverseHead<[]>
 *   ```
 */
export type TupleReverseHead<T extends readonly unknown[]> = T extends readonly [
  ...infer Rest,
  infer Last,
]
  ? [...TupleReverse<Rest>, Last]
  : []

/**
 * @description Reverse all but the first element of a tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 3, 2]
 *   type Example1 = TupleReverseTail<[1, 2, 3]>
 *   // Expect: []
 *   type Example2 = TupleReverseTail<[]>
 *   ```
 */
export type TupleReverseTail<T extends readonly unknown[]> = T extends readonly [
  infer First,
  ...infer Rest,
]
  ? [First, ...TupleReverse<Rest>]
  : []

type InternalTupleRotateLeft<T extends readonly unknown[], N extends number> = N extends 0
  ? T
  : InternalTupleRotateLeft<TupleConcat<TupleTail<T>, [TupleHead<T>]>, InternalSubtract<N, 1>>
/**
 * @description Rotate a tuple left by N.
 *
 * @example
 *   ```
 *   // Expect: [2, 3, 1]
 *   type Example1 = TupleRotateLeft<[1, 2, 3], 1>
 *   // Expect: [1, 2]
 *   type Example2 = TupleRotateLeft<[1, 2], 0>
 *   ```
 */
export type TupleRotateLeft<
  T extends readonly unknown[],
  N extends number = 1,
> = InternalTupleRotateLeft<T, N>

type InternalTupleRotateRight<T extends readonly unknown[], N extends number> = N extends 0
  ? T
  : InternalTupleRotateRight<TupleConcat<[TupleLast<T>], TuplePrev<T>>, InternalSubtract<N, 1>>
/**
 * @description Rotate a tuple right by N.
 *
 * @example
 *   ```
 *   // Expect: [3, 1, 2]
 *   type Example1 = TupleRotateRight<[1, 2, 3], 1>
 *   // Expect: [1, 2]
 *   type Example2 = TupleRotateRight<[1, 2], 0>
 *   ```
 */
export type TupleRotateRight<
  T extends readonly unknown[],
  N extends number = 1,
> = InternalTupleRotateRight<T, N>

/**
 * @description Move an element from index From to index To.
 *
 * @example
 *   ```
 *   // Expect: [2, 3, 1]
 *   type Example1 = TupleMove<[1, 2, 3], 0, 2>
 *   // Expect: [1, 2, 3]
 *   type Example2 = TupleMove<[1, 2, 3], 1, 1>
 *   ```
 */
export type TupleMove<
  T extends readonly unknown[],
  From extends number,
  To extends number,
> = TupleInsert<TupleRemoveAt<T, From>, To, TupleAt<T, From>>

/**
 * @description Swap each adjacent pair of elements.
 *
 * @example
 *   ```
 *   // Expect: [2, 1, 4, 3]
 *   type Example1 = TupleSwapPairs<[1, 2, 3, 4]>
 *   // Expect: [1]
 *   type Example2 = TupleSwapPairs<[1]>
 *   ```
 */
export type TupleSwapPairs<T extends readonly unknown[]> = T extends readonly [
  infer A,
  infer B,
  ...infer Rest,
]
  ? [B, A, ...TupleSwapPairs<Rest>]
  : T

/**
 * @description Interleave two tuples.
 *
 * @example
 *   ```
 *   // Expect: [1, 'a', 2, 'b']
 *   type Example1 = TupleInterleave<[1, 2], ['a', 'b']>
 *   // Expect: [1]
 *   type Example2 = TupleInterleave<[1], []>
 *   ```
 */
export type TupleInterleave<
  A extends readonly unknown[],
  B extends readonly unknown[],
> = A extends readonly [infer FirstA, ...infer RestA]
  ? B extends readonly [infer FirstB, ...infer RestB]
    ? [FirstA, FirstB, ...TupleInterleave<RestA, RestB>]
    : [FirstA, ...TupleInterleave<RestA, []>]
  : B extends readonly [infer FirstB, ...infer RestB]
    ? [FirstB, ...TupleInterleave<[], RestB>]
    : []

type InternalTupleZipLongestHelper<
  A extends readonly unknown[],
  B extends readonly unknown[],
  Fill,
> = A extends readonly [infer FirstA, ...infer RestA]
  ? B extends readonly [infer FirstB, ...infer RestB]
    ? [[FirstA, FirstB], ...InternalTupleZipLongestHelper<RestA, RestB, Fill>]
    : [[FirstA, Fill], ...InternalTupleZipLongestHelper<RestA, [], Fill>]
  : B extends readonly [infer FirstB, ...infer RestB]
    ? [[Fill, FirstB], ...InternalTupleZipLongestHelper<[], RestB, Fill>]
    : []
/**
 * @description Zip two tuples, filling missing entries.
 *
 * @example
 *   ```
 *   // Expect: [[1, 'a'], [2, undefined]]
 *   type Example1 = TupleZipLongest<[1, 2], ['a']>
 *   // Expect: []
 *   type Example2 = TupleZipLongest<[], []>
 *   ```
 */
export type TupleZipLongest<
  A extends readonly unknown[],
  B extends readonly unknown[],
  Fill = undefined,
> = InternalTupleZipLongestHelper<A, B, Fill>

/**
 * @description Pad both sides to length N (favoring end for odd remainder).
 *
 * @example
 *   ```
 *   // Expect: [0, 1, 2, 0]
 *   type Example1 = TuplePad<[1, 2], 4, 0>
 *   // Expect: [1]
 *   type Example2 = TuplePad<[1], 1, 0>
 *   ```
 */
export type TuplePad<
  T extends readonly unknown[],
  N extends number,
  Fill = undefined,
> = TuplePadEnd<TuplePadStart<T, N, Fill>, N, Fill>

type InternalTupleFlattenDepth<T extends readonly unknown[], Depth extends number> = Depth extends 0
  ? T
  : T extends readonly [infer First, ...infer Rest]
    ? First extends readonly unknown[]
      ? [
          ...InternalTupleFlattenDepth<First, InternalSubtract<Depth, 1>>,
          ...InternalTupleFlattenDepth<Rest, Depth>,
        ]
      : [First, ...InternalTupleFlattenDepth<Rest, Depth>]
    : []
/**
 * @description Flatten a tuple to a given depth.
 *
 * @example
 *   ```
 *   // Expect: [1, 2, [3]]
 *   type Example1 = TupleFlattenToDepth<[[1], [2, [3]]], 1>
 *   // Expect: [1, 2, 3]
 *   type Example2 = TupleFlattenToDepth<[[1], [2, [3]]], 2>
 *   ```
 */
export type TupleFlattenToDepth<
  T extends readonly unknown[],
  Depth extends number,
> = InternalTupleFlattenDepth<T, Depth>

// ============================================================================
// Conversion
// ============================================================================

/**
 * @description Convert a tuple to a union of its element types.
 *
 * @example
 *   ```
 *   // Expect: 1 | 2
 *   type Example1 = TupleToUnion<[1, 2]>
 *   // Expect: never
 *   type Example2 = TupleToUnion<[]>
 *   ```
 */
export type TupleToUnion<T extends readonly unknown[]> = T[number]

/**
 * @description Convert a tuple of keys to an object with identical values.
 *
 * @example
 *   ```
 *   // Expect: { a: 'a'; b: 'b' }
 *   type Example1 = TupleToObject<['a', 'b']>
 *   // Expect: {}
 *   type Example2 = TupleToObject<[]>
 *   ```
 */
export type TupleToObject<T extends readonly PropertyKey[]> = {
  [K in T[number]]: K
}

/**
 * @description Convert a tuple of [key, value] pairs to a record.
 *
 * @example
 *   ```
 *   // Expect: { a: 1; b: 2 }
 *   type Example1 = TupleToRecord<[['a', 1], ['b', 2]]>
 *   // Expect: {}
 *   type Example2 = TupleToRecord<[]>
 *   ```
 */
export type TupleToRecord<T extends ReadonlyArray<readonly [PropertyKey, unknown]>> = {
  [K in T[number] as K extends readonly [infer Key extends PropertyKey, unknown]
    ? Key
    : never]: K extends readonly [PropertyKey, infer Value] ? Value : never
}

/**
 * @description Join tuple elements into a string with a separator.
 *
 * @example
 *   ```
 *   // Expect: 'a-b'
 *   type Example1 = TupleToString<['a', 'b'], '-'>
 *   // Expect: ''
 *   type Example2 = TupleToString<[], '-'>
 *   ```
 */
export type TupleToString<
  T extends ReadonlyArray<string | number | boolean>,
  Sep extends string = "",
> = T extends readonly [
  infer First extends string | number | boolean,
  ...infer Rest extends Array<string | number | boolean>,
]
  ? Rest extends []
    ? `${First}`
    : `${First}${Sep}${TupleToString<Rest, Sep>}`
  : ""

/**
 * @description Convert a tuple to an array of its element union.
 *
 * @example
 *   ```
 *   // Expect: Array<1 | 2>
 *   type Example1 = TupleToArray<[1, 2]>
 *   // Expect: Array<never>
 *   type Example2 = TupleToArray<[]>
 *   ```
 */
export type TupleToArray<T extends readonly unknown[]> = Array<T[number]>

type InternalUnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (
  value: infer I,
) => void
  ? I
  : never
/**
 * @description Convert a tuple to an intersection of its elements.
 *
 * @example
 *   ```
 *   // Expect: { a: 1 } & { b: 2 }
 *   type Example1 = TupleToIntersection<[{ a: 1 }, { b: 2 }]>
 *   // Expect: unknown
 *   type Example2 = TupleToIntersection<[]>
 *   ```
 */
export type TupleToIntersection<T extends readonly unknown[]> =
  InternalUnionToIntersection<T[number]> extends infer R
    ? R extends unknown
      ? R
      : unknown
    : unknown

/**
 * @description Convert a tuple of [key, value] pairs to a Map type.
 *
 * @example
 *   ```
 *   // Expect: Map<'a' | 'b', 1 | 2>
 *   type Example1 = TupleToMap<[['a', 1], ['b', 2]]>
 *   // Expect: Map<never, never>
 *   type Example2 = TupleToMap<[]>
 *   ```
 */
export type TupleToMap<T extends ReadonlyArray<readonly [PropertyKey, unknown]>> = Map<
  T[number] extends readonly [infer Key extends PropertyKey, unknown] ? Key : never,
  T[number] extends readonly [PropertyKey, infer Value] ? Value : never
>

/**
 * @description Convert a tuple to a Set type.
 *
 * @example
 *   ```
 *   // Expect: Set<1 | 2>
 *   type Example1 = TupleToSet<[1, 2]>
 *   // Expect: Set<never>
 *   type Example2 = TupleToSet<[]>
 *   ```
 */
export type TupleToSet<T extends readonly unknown[]> = Set<T[number]>

/**
 * @description Make all tuple elements optional.
 *
 * @example
 *   ```
 *   // Expect: [number?, string?]
 *   type Example1 = TupleToOptional<[number, string]>
 *   // Expect: []
 *   type Example2 = TupleToOptional<[]>
 *   ```
 */
export type TupleToOptional<T extends readonly unknown[]> = { [K in keyof T]?: T[K] }

/**
 * @description Make all tuple elements required.
 *
 * @example
 *   ```
 *   // Expect: [number, string]
 *   type Example1 = TupleToRequired<[number?, string?]>
 *   // Expect: []
 *   type Example2 = TupleToRequired<[]>
 *   ```
 */
export type TupleToRequired<T extends readonly unknown[]> = { [K in keyof T]-?: T[K] }

/**
 * @description Convert a tuple to function parameters (identity).
 *
 * @example
 *   ```
 *   // Expect: [number, string]
 *   type Example1 = TupleToFunctionParams<[number, string]>
 *   // Expect: []
 *   type Example2 = TupleToFunctionParams<[]>
 *   ```
 */
export type TupleToFunctionParams<T extends readonly unknown[]> = T

/**
 * @description Get a function return type from a tuple (last element).
 *
 * @example
 *   ```
 *   // Expect: string
 *   type Example1 = TupleToFunctionReturn<[number, string]>
 *   // Expect: never
 *   type Example2 = TupleToFunctionReturn<[]>
 *   ```
 */
export type TupleToFunctionReturn<T extends readonly unknown[]> = TupleLast<T>

/**
 * @description Convert a tuple to a union of single-element tuples.
 *
 * @example
 *   ```
 *   // Expect: [1] | [2]
 *   type Example1 = TupleToUnionOfTuples<[1, 2]>
 *   // Expect: never
 *   type Example2 = TupleToUnionOfTuples<[]>
 *   ```
 */
export type TupleToUnionOfTuples<T extends readonly unknown[]> = { [K in keyof T]: [T[K]] }[number]

/**
 * @description Convert a tuple to a readonly tuple.
 *
 * @example
 *   ```
 *   // Expect: readonly [1, 2]
 *   type Example1 = TupleToReadonly<[1, 2]>
 *   // Expect: readonly []
 *   type Example2 = TupleToReadonly<[]>
 *   ```
 */
export type TupleToReadonly<T extends readonly unknown[]> = Readonly<T>

/**
 * @description Convert a tuple to a mutable tuple.
 *
 * @example
 *   ```
 *   // Expect: [1, 2]
 *   type Example1 = TupleToMutable<readonly [1, 2]>
 *   // Expect: []
 *   type Example2 = TupleToMutable<readonly []>
 *   ```
 */
export type TupleToMutable<T extends readonly unknown[]> = { -readonly [K in keyof T]: T[K] }