import { DeepPartial } from "./objects";
import { Join } from "./strings";

export type IsAny<T> = 0 extends (1 & T) ? true : false;
export type IsNever<T> = [T] extends [never] ? true : false;
export type IsNullish<T> = [T] extends [null | undefined] ? true : false;
export type IsUnion<T, U = T> =
  IsNever<T> extends true ? false
  : IsAny<T> extends true ? false
    : T extends U // distributive conditional https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
        ? /* if the *whole* original type (`U`) still fits inside the current variant, then `T` wasn’t a union */ ([U] extends [T] ? false : true)
        : never;

export type NullishCoalesce<T, U> = T extends null | undefined ? U : T;

export type LastUnionElement<U> = UnionToIntersection<U extends any ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L & U : never;

type primitive = string | number | boolean | bigint | symbol | null | undefined;

/**
 * Makes a type prettier by recursively expanding all object types. For example, `Omit<{ a: 1 }, "a">` becomes just `{}`.
 */
export type Expand<T> = T extends (...args: infer A) => infer R
  ? ((...args: A) => R) extends T
    ? (...args: Expand<A>) => Expand<R>
    : ((...args: Expand<A>) => Expand<R>) & { [K in keyof T]: Expand<T[K]> }
  : T extends object
    ? T extends primitive
      ? T
      : T extends infer O
        ? { [K in keyof O]: Expand<O[K]> }
        : never
    : T;


/**
 * Removes all optional undefined/never keys from an object.
 */
export type DeepRemoveOptionalUndefined<T> = T extends object ? { [K in keyof T]: DeepRemoveOptionalUndefined<T[K]> } : T;

// why this works: https://stackoverflow.com/a/50375286
export type UnionToIntersection<U> =
  (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never

type _UnionToTupleInner<U, R extends any[], Last> = UnionToTuple<Exclude<U, Last>, [...R, Last]>
export type UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : _UnionToTupleInner<U, R, LastUnionElement<U>>;

export type CollapseObjectUnion<T extends object> = {
  [K in AllUnionKeys<T>]?: T extends Record<K, infer V> ? V : never;
};
typeAssertIs<CollapseObjectUnion<{ a: string } | { b: number }>, { a?: string, b?: number }>()();
typeAssertIs<CollapseObjectUnion<{ a: string } | { a: number }>, { a?: string | number }>()();

export type IntersectAll<T extends any[]> = UnionToIntersection<T[number]>;

export type OptionalKeys<T> = {
  [K in keyof T]: {} extends Pick<T, K> ? K : never;
}[keyof T];
export type RequiredKeys<T> = {
  [K in keyof T]: {} extends Pick<T, K> ? never : K;
}[keyof T];

/**
 * Returns a type whose keys are the intersection of the keys of T and U, deeply.
 */
export type KeyIntersect<T, U> =
  & { [K in keyof T & keyof U]?: T[K] & U[K] }
  & { [K in RequiredKeys<T> & keyof U]: T[K] & U[K] }
  & { [K in RequiredKeys<U> & keyof T]: U[K] & T[K] }

/**
 * Returns ALL keys of all union elements.
 */
export type AllUnionKeys<T extends object> = T extends T ? keyof T : never;
typeAssertIs<AllUnionKeys<{ a: string } | { b: number }>, "a" | "b">()();

export type SubtractType<T, U> = T extends object ? { [K in keyof T]: K extends keyof U ? SubtractType<T[K], U[K]> : T[K] } : (T extends U ? never : T); // note: this only works due to the distributive property of conditional types https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types

export type XOR<T extends readonly any[]> = T extends readonly [infer A, infer B, ...infer Rest]
  ? Rest extends []
  ? (A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never })
  : XOR<[(A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never }), ...Rest]>
  : T[0];


type _AntiIntersectInner<T, U> = T extends object ? (
  & Omit<U, keyof T>
  & { [K in keyof Pick<U, { [K in keyof T & keyof U]: U[K] extends T[K] ? (T[K] extends U[K] ? never : K) : never }[keyof T & keyof U]>]: PseudoAntiIntersect<T[K], U[K]> }
  & { [K in keyof Pick<U, keyof T & keyof U>]?: PseudoAntiIntersect<T[K], U[K]> }
) : U;
/**
 * Returns a type R such that T & R = U.
 */
export type AntiIntersect<T, U> = U extends T ? _AntiIntersectInner<T, U> : "Cannot anti-intersect a type with a type that is not a subtype of it"; // NOTE: This type is mostly untested — not sure how well it works on the edge cases
export type PseudoAntiIntersect<T, U> = _AntiIntersectInner<T, T & U>;

/**
 * A variation of TypeScript's conditionals with slightly different semantics. It is the perfect type for cases where:
 *
 * - If all possible values are contained in `Extends`, then it will be mapped to `Then`.
 * - If all possible values are not contained in `Extends`, then it will be mapped to `Otherwise`.
 * - If some possible values are contained in `Extends` and some are not, then it will be mapped to `Then | Otherwise`.
 *
 * This is different from TypeScript's built-in conditional types (`Value extends Extends ? Then : Otherwise`), which
 * returns `Otherwise` for the third case (causing unsoundness in many real-world cases).
 */
export type IfAndOnlyIf<Value, Extends, Then, Otherwise> =
  | (Value extends Extends ? never : Otherwise)
  | (Value & Extends extends never ? never : Then);


/**
 * Can be used to prettify a type in the IDE; for example, some complicated intersected types can be flattened into a single type.
 */
export type PrettifyType<T> = T extends object ? { [K in keyof T]: T[K] } & {} : T;

type _ToStringAndJoin<T extends any[], Separator extends string> =
  T extends [infer U, ...infer Rest extends any[]]
    ? `${TypeToString<U>}${Rest extends [any, ...any[]] ? `${Separator}${_ToStringAndJoin<Rest, Separator>}` : ""}`
    : "<error-joining-tuple-elements>";
type _TypeToStringInner<T> =
  IsAny<T> extends true ? "any"
  : IsNever<T> extends true ? "never"
  : IsUnion<T> extends true ? _ToStringAndJoin<UnionToTuple<T>, " | ">
  : [T] extends [number] ? (number extends T ? "number" : `${T}`)
  : [T] extends [boolean] ? `${T}`
  : [T] extends [undefined] ? "undefined"
  : [T] extends [null] ? "null"
  : [T] extends [string] ? (string extends T ? "string" : `'${T}'`)
  : [T] extends [[]] ? "[]"
  : [T] extends [[any, ...any[]]] ? `[${_ToStringAndJoin<T, ", ">}]`
  : [T] extends [(infer E)[]] ? `${TypeToString<E>}[]`
  : [T] extends [Function] ? "function"
  : [T] extends [symbol] ? `symbol(${T['description']})`
  : [T] extends [object] ? `{ ${Join<UnionToTuple<{ [K in keyof T]: `${TypeToString<K>}: ${TypeToString<T[K]>}` }[keyof T]>, ", ">} }`
  : "<unknown-type>"
export type TypeToString<T> = _TypeToStringInner<T> extends `${infer S}` ? S : never;

/**
 * Can be used to create assertions on types. For example, if passed any T other than `true`, the following will
 * show a type error:
 *
 * ```ts
 * typeAssert<T>()();  // the second pair of braces is important!
 * ```
 */
export function typeAssert<T>(): (
  IsAny<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got any.`>
    : IsNever<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got never.`>
    : T extends true ? (() => undefined)
    : TypeAssertionError<`Type assertion failed. Expected true, but got: ${TypeToString<T>}`>
) {
  return (() => undefined) as any;
}
type TypeAssertionError<T> =
  & [T]
  & /* this promise makes sure that if we accidentally forget the second pair of braces, eslint will complain (if we have no-floating-promises enabled) */ Promise<any>;


typeAssertExtends<ReturnType<typeof typeAssert<true>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssert<false>>, TypeAssertionError<`Type assertion failed. Expected true, but got: false`>>()();
typeAssertExtends<ReturnType<typeof typeAssert<never>>, TypeAssertionError<`Type assertion failed. Expected true, but got never.`>>()();
typeAssertExtends<ReturnType<typeof typeAssert<any>>, TypeAssertionError<`Type assertion failed. Expected true, but got any.`>>()();

/**
 * Functionally equivalent to `typeAssert<T extends S ? true : false>()()`, but with better error messages.
 */
export function typeAssertExtends<T, S>(): (
  [T] extends [S] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to extend ${TypeToString<S>}`>
) {
  return (() => undefined) as any;
}

typeAssertExtends<ReturnType<typeof typeAssertExtends<never, true>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<any, true>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<false, false>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<"abc", string>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<{a: 1, b: 123}, {a: number}>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<never, never>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<true, any>>, () => undefined>()();

typeAssertExtends<ReturnType<typeof typeAssertExtends<{a: number}, {a: 1}>>, ["Type assertion failed. Expected { 'a': number } to extend { 'a': 1 }"]>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<any, never>>, ["Type assertion failed. Expected any to extend never"]>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<false, true>>, ["Type assertion failed. Expected false to extend true"]>()();
typeAssertExtends<ReturnType<typeof typeAssertExtends<false, never>>, ["Type assertion failed. Expected false to extend never"]>()();


export function typeAssertIs<T, U>(): (
  IsAny<T> extends true ? (IsAny<U> extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)
    : IsAny<U> extends true ? TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>
    : [T] extends [U] ? ([U] extends [T] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)
    : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>
) {
  return (() => undefined) as any;
}

typeAssertExtends<ReturnType<typeof typeAssertIs<"123", "123">>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<{a: 1}, {a: 1}>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<DeepPartial<{a: 1}>, {a?: 1}>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<any, any>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<never, never>>, () => undefined>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<1, any>>, ["Type assertion failed. Expected 1 to be any"]>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<any, 1>>, ["Type assertion failed. Expected any to be 1"]>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, ["Type assertion failed. Expected false to be true"]>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<{a: number}, {a: 1}>>, ["Type assertion failed. Expected { 'a': number } to be { 'a': 1 }"]>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<any, never>>, ["Type assertion failed. Expected any to be never"]>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, ["Type assertion failed. Expected false to be true"]>()();
typeAssertExtends<ReturnType<typeof typeAssertIs<false, never>>, ["Type assertion failed. Expected false to be never"]>()();