import type {If} from './if.d.ts';
import type {IsReadonlyArray} from './is-readonly-array.d.ts';
import type {IfNotAnyOrNever} from './internal/type.d.ts';
import type {UnknownArray} from './unknown-array.d.ts';

/**
Reverse the order of elements in a tuple type.

@example
```ts
import type {ArrayReverse} from 'type-fest';

type A = ArrayReverse<[string, number, boolean]>;
//=> [boolean, number, string]

type B = ArrayReverse<readonly [string, number, ...boolean[]]>;
//=> readonly [...boolean[], number, string]

type C = ArrayReverse<['foo', 'bar'] | readonly [1, 2, 3]>;
//=> ['bar', 'foo'] | readonly [3, 2, 1]

type D = ArrayReverse<string[]>;
//=> string[]

type E = ArrayReverse<[]>;
//=> []
```

Optional elements are assumed to form a dense prefix. Sparse tuples with holes in optional positions are unsupported; include `undefined` explicitly when it is a possible element value.

Note: If the tuple contains optional elements, the result will be a union of tuples, refer to the examples below:

@example
```ts
import type {ArrayReverse} from 'type-fest';

type A = ArrayReverse<[string, number, boolean?]>;
//=> [number, string] | [boolean, number, string]

type B = ArrayReverse<[string, number?, boolean?]>;
//=> [string] | [number, string] | [boolean, number, string]

type C = ArrayReverse<[string?, number?, boolean?]>;
//=> [] | [string] | [number, string] | [boolean, number, string]

type D = ArrayReverse<[string, number?, ...boolean[]]>;
//=> [string] | [...boolean[], number, string]

type E = ArrayReverse<[string?, number?, ...boolean[]]>;
//=> [] | [string] | [...boolean[], number, string]
```

@category Array
*/
export type ArrayReverse<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {
	ifNot: TArray extends unknown // For distributing `TArray`
		? _ArrayReverse<TArray> extends infer Result
			? If<IsReadonlyArray<TArray>, Readonly<Result>, Result>
			: never // Should never happen
		: never; // Should never happen
}>;

type _ArrayReverse<
	TArray extends UnknownArray,
	BeforeRestAcc extends UnknownArray = [],
	AfterRestAcc extends UnknownArray = [],
	Result extends UnknownArray = never,
> =
	'0' extends keyof TArray
		// Enters this branch, if `TArray` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
		? TArray extends readonly [infer First, infer Second, infer Third, infer Fourth, infer Fifth, ...infer Rest]
			// Consume five required elements at once to reduce recursion and tuple slicing.
			? _ArrayReverse<Rest, [Fifth, Fourth, Third, Second, First, ...BeforeRestAcc], AfterRestAcc, Result>
			: TArray extends readonly [(infer First)?, ...infer Rest]
				// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends TArray`, are several times slower.
				? TArray extends readonly [unknown, ...unknown[]]
					? _ArrayReverse<Rest, [First, ...BeforeRestAcc], AfterRestAcc, Result>
					: _ArrayReverse<
						Rest,
						[First, ...BeforeRestAcc], // Optional inference preserves explicitly declared `undefined`.
						AfterRestAcc,
						Result | BeforeRestAcc
					>
				: never // Should never happen, since `readonly [(infer First)?, ...infer Rest]` is a top-type for arrays.
		// Enters this branch, if `TArray` is empty (e.g., `[]`),
		// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
		: TArray extends readonly [...infer Rest, infer First, infer Second, infer Third, infer Fourth, infer Fifth]
			// Consume five required suffix elements at once to reduce recursion and tuple slicing.
			? _ArrayReverse<Rest, BeforeRestAcc, [...AfterRestAcc, Fifth, Fourth, Third, Second, First], Result>
			: TArray extends readonly [...infer Rest, infer Last]
				? _ArrayReverse<Rest, BeforeRestAcc, [...AfterRestAcc, Last], Result> // Accumulate elements that are present after the rest element in reverse order.
				: Result | [...AfterRestAcc, ...TArray, ...BeforeRestAcc]; // Add the rest element between the accumulated elements.

export {};
