// oxlint-disable no-empty-object-type
// oxlint-disable no-unsafe-function-type
// oxlint-disable no-explicit-any

import type {
  Nilable,
  NonNilable,
  NonNullable,
  NonUndefinedable,
  Nullable,
  Undefinedable,
} from "./is.ts"
import type { UnionComplement, UnionDifference, UnionIntersection } from "./union.ts"

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

/**
 * @description Strict version of `Omit`, `K` must be subset of `typeof T`.
 */
export type StrictOmit<T, K extends keyof T> = Omit<T, K>

/**
 * @description 表示键为字符串的记录类型。
 */
export type StringRecord<T> = Record<string, T>
/**
 * @description 表示键为数字的记录类型。
 */
export type NumberRecord<T> = Record<number, T>
/**
 * @description 表示键为符号的记录类型。
 */
export type SymbolRecord<T> = Record<symbol, T>
/**
 * @description 表示键可以是字符串、数字或符号的记录类型。
 */
export type HybridRecord<T> = Record<string | number | symbol, T>
/**
 * @description 表示值类型为 `any` 的字符串键记录类型。
 */
export type AnyStringRecord = StringRecord<any>
/**
 * @description 表示值类型为 `any` 的数字键记录类型。
 */
export type AnyNumberRecord = NumberRecord<any>
/**
 * @description 表示值类型为 `any` 的符号键记录类型。
 */
export type AnySymbolRecord = SymbolRecord<any>
/**
 * @description 表示值类型为 `any` 的混合键记录类型。
 */
export type AnyHybridRecord = Record<string | number | symbol, any>
/**
 * @description 表示任意常见记录类型的联合。
 */
export type AnyRecord = AnyStringRecord | AnyNumberRecord | AnySymbolRecord

/**
 * @description 为对象类型附加一个依赖其键集合的品牌标记。
 */
export type ObjectExact<A extends object> = A & { __brand: keyof A }

export type ObjectPrettify<T extends AnyHybridRecord> = {
  [K in keyof T]: T[K]
} & {}
/**
 * @description 通过条件分发重新构造对象类型，以获得更易读的展开结果。
 *
 * 这个版本会让字符串字面量泛化成 string。
 */
export type ObjectPrettify2<Target extends AnyHybridRecord> = Target extends infer O
  ? { [K in keyof O]: O[K] }
  : never
/**
 * @description 重新映射对象类型，使其在编辑器中以展开后的结构显示。
 *
 * @see {@link https://stackoverflow.com/questions/78453542/intersection-with-object-in-prettify-helper-type}
 * @see {@link https://github.com/mylesmmurphy/prettify-ts}
 */
export type ObjectPrettify3<Target extends AnyHybridRecord> = Pick<Target, keyof Target>

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

/**
 * @description If the `Target` is an empty Record/Object, then return `true`.
 *
 * @example
 *   ```
 *   // Expect: true
 *   type Example1 = ObjectIsEmpty<{}>
 *   // Expect: false
 *   type Example2 = ObjectIsEmpty<{ a: number }>
 *   ```
 */
export type ObjectIsEmpty<Target extends AnyStringRecord> = keyof Target extends never
  ? true
  : false

/**
 * @description If the `Target` is an empty Record/Object, then return `never`.
 *
 * @see {@link https://github.com/ts-essentials/ts-essentials#nonemptyobject}
 * @see {@link https://github.com/ts-essentials/ts-essentials/tree/master/lib/non-empty-object}
 */
export type ObjectNonEmpty<Target extends AnyStringRecord> = keyof Target extends never
  ? never
  : Target

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

/**
 * @description Get the keys of an object type.
 *
 * @example
 *   ```
 *   interface Props { name: string, age: number, visible: boolean }
 *   // Expect: 'name' | 'age' | 'visible'
 *   type Example1 = ObjectKeys<Props>
 *   ```
 */
export type ObjectKeys<Target> = Target extends AnyHybridRecord ? keyof Target : never

/**
 * @example
 *   ```
 *   interface Props { name: string, age: number, visible: boolean }
 *   // Expect: string | number | boolean
 *   type Example1 = ObjectValues<Props>
 *   ```
 */
export type ObjectValues<Target> = Target extends AnyHybridRecord ? Target[keyof Target] : never

/**
 * @example
 *   ```
 *   type MixedProps = {name: string; setName: (name: string) => void; someKeys?: string; someFn?: (...args: any) => any;};
 *
 *   // Expect: "setName | someFn"
 *   type Example1 = FunctionKeys<MixedProps>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type FunctionKeys<Target extends AnyHybridRecord> = {
  [Key in keyof Target]-?: NonUndefinedable<Target[Key]> extends Function ? Key : never
}[keyof Target]
/**
 * @example
 *   ```
 *   type MixedProps = {name: string; setName: (name: string) => void; someKeys?: string; someFn?: (...args: any) => any;};
 *
 *   // Expect: "name | someKey"
 *   type Example1 = NonFunctionKeys<MixedProps>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type NonFunctionKeys<Target extends AnyHybridRecord> = {
  [Key in keyof Target]-?: NonUndefinedable<Target[Key]> extends Function ? never : Key
}[keyof Target]

/**
 * @see {@link https://github.com/ts-essentials/ts-essentials/blob/5aa1f264e77fb36bb3f673c49f00927c7c181a7f/lib/types.ts#L440 warning}
 * @see {@link https://stackoverflow.com/a/52473108/1815209 explain with comments}
 */
type IfEquals<X, Y, A = X, B = never> =
  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B
/**
 * @example
 *   ```
 *   type Props = { readonly foo: string; bar: number };
 *   // Expect: "foo"
 *   type Example1 = ReadonlyKeys<Props>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 * @see {@link https://stackoverflow.com/questions/52443276/how-to-exclude-getter-only-properties-from-type-in-typescript}
 */
export type ReadonlyKeys<Target extends AnyHybridRecord> = {
  [Key in keyof Target]-?: IfEquals<
    { [Q in Key]: Target[Key] },
    { -readonly [Q in Key]: Target[Key] },
    never,
    Key
  >
}[keyof Target]
/**
 * @example
 *   ```
 *   interface Props { readonly foo: string, bar: number }
 *   // Expect: "bar"
 *   type Example1 = WritableKeys<Props>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 * @see {@link https://stackoverflow.com/questions/52443276/how-to-exclude-getter-only-properties-from-type-in-typescript}
 */
export type WritableKeys<Target extends AnyHybridRecord> = {
  [Key in keyof Target]-?: IfEquals<
    { [Q in Key]: Target[Key] },
    { -readonly [Q in Key]: Target[Key] },
    Key,
    never
  >
}[keyof Target]

/**
 * @example
 *   ```
 *   type Props = { req: number; reqUndef: number | undefined; opt?: string; optUndef?: number | undefined; };
 *   // Expect: "req" | "reqUndef"
 *   type Example1 = RequiredKeys<Props>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 * @see {@link https://stackoverflow.com/questions/52984808/is-there-a-way-to-get-all-required-properties-of-a-typescript-object}
 */
export type RequiredKeys<Target> = {
  [Key in keyof Target]-?: Record<string | number | symbol, never> extends Pick<Target, Key>
    ? never
    : Key
}[keyof Target]
/**
 * @example
 *   ```
 *   type Props = { req: number; reqUndef: number | undefined; opt?: string; optUndef?: number | undefined; };
 *   // Expect: "opt" | "optUndef"
 *   type Example1 = OptionalKeys<Props>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 * @see {@link https://stackoverflow.com/questions/52984808/is-there-a-way-to-get-all-required-properties-of-a-typescript-object}
 */
export type OptionalKeys<Target> = {
  [Key in keyof Target]-?: Record<string | number | symbol, never> extends Pick<Target, Key>
    ? Key
    : never
}[keyof Target]

/**
 * @example
 *   ```
 *   interface Temp { req: number, reqUndef: number | undefined, opt?: string }
 *   // Expect: 'req'
 *   type Example1 = PickKeysByValue<Temp, number>
 *   // Expect: 'req' | 'reqUndef'
 *   type Example2 = PickKeysByValue<Temp, number | undefined>
 *   ```
 * (For ALL `ByValue` utilities) When we want to get 'opt' as result in above example, `PickKeysByValue<Temp, string>`
 * will not work. We should use `PickKeysByValue<Temp, string | undefined>` instead. It's so weird that we don't always
 * know whether the target key is optional or not in actual most of situations so we have to include `undefined`
 * in the target matching `ValueType`'s union. It's unnecessary and redundant.
 *
 * On the other hand, normal keys and optional keys are quite different. We indeed need an approach to
 * distinguish them. Seems like add `undefined` to the union of optional keys' value type is a reasonable way.
 *
 * Here our final choice is give `undefined` a chance until we get a more fantastic solution. Meanwhile, turn the
 * `exactOptionalPropertyTypes: true` typescript's compiler option on. It will make the use of `undefined` on optional
 * properties more reasonable. For more information on it: see {@link https://www.typescriptlang.org/tsconfig#exactOptionalPropertyTypes},
 * there's also a use guide on that information, see {@link https://tkdodo.eu/blog/optional-vs-undefined}.
 */
export type PickKeysByValue<Target, ValueType> = {
  [Key in keyof Target]-?: Target[Key] extends ValueType ? Key : never
}[keyof Target]
/**
 * @example
 *   ```
 *   interface Temp { req: number, reqUndef: number | undefined, opt?: string }
 *   // Expect: 'req'
 *   type Example1 = PickKeysByValue<Temp, number>
 *   // Expect: 'reqUndef'
 *   type Example2 = PickKeysByValue<Temp, number | undefined>
 *   ```
 */
export type PickKeysByValueExact<Target, ValueType> = {
  [Key in keyof Target]-?: [ValueType] extends [Target[Key]]
    ? [Target[Key]] extends [ValueType]
      ? Key
      : never
    : never
}[keyof Target]

/**
 * @example
 *   ```
 *   interface Temp { req: number, reqUndef: number | undefined, opt?: string }
 *   // Expect: { req: number }
 *   type Example1 = PickByValue<Temp, number>
 *   // Expect: { req: number; reqUndef: number | undefined; }
 *   type Example2 = PickByValue<Temp, number | undefined>
 *   ```
 *
 * @see {@link https://medium.com/dailyjs/typescript-create-a-condition-based-subset-types-9d902cea5b8c}
 */
export type PickByValue<Target, ValueType> = Pick<Target, PickKeysByValue<Target, ValueType>>
/**
 * @example
 *   ```
 *   interface Temp { req: number, reqUndef: number | undefined, opt?: string }
 *   // Expect: { req: number }
 *   type Example1 = PickByValueExact<Temp, number>
 *   // Expect: { reqUndef: number | undefined; }
 *   type Example2 = PickByValueExact<Temp, number | undefined>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type PickByValueExact<Target, ValueType> = Pick<
  Target,
  PickKeysByValueExact<Target, ValueType>
>

/**
 * @example
 *   ```
 *   interface Temp { req: number, reqUndef: number | undefined, opt?: string }
 *   // Expect: { reqUndef: number | undefined; opt?: string; }
 *   type Example1 = OmitByValue<Temp, number>
 *   // Expect: { opt?: string; }
 *   type Example2 = OmitByValue<Temp, number | undefined>
 *   ```
 *
 * @see {@link https://medium.com/dailyjs/typescript-create-a-condition-based-subset-types-9d902cea5b8c}
 */
export type OmitByValue<Target, ValueType> = Omit<Target, PickKeysByValue<Target, ValueType>>
/**
 * @example
 *   ```
 *   interface Temp { req: number, reqUndef: number | undefined, opt?: string }
 *   // Expect: { reqUndef: number | undefined; opt?: string; }
 *   type Example1 = OmitByValueExact<Temp, number>
 *   // Expect: { req: number; opt?: string }
 *   type Example2 = OmitByValueExact<Temp, number | undefined>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type OmitByValueExact<Target, ValueType> = Omit<
  Target,
  PickKeysByValueExact<Target, ValueType>
>

/**
 * @description ObjectNamedKeys
 *
 * @example
 *   ```
 *   interface Temp {
 *     name: string
 *     age?: number
 *     [key: string]: string | number
 *   }
 *   // Expect: 'name' | 'age'
 *   type Example1 = ObjectNamedKeys<Temp>
 *   ```
 *
 * @see {@link https://github.com/millsp/ts-toolbelt/blob/319e55123b9571d49f34eca3e5926e41ca73e0f3/sources/Any/KnownKeys.ts#L11}
 * @see {@link https://github.com/millsp/ts-toolbelt/issues/164 issue}
 * @see {@link https://stackoverflow.com/questions/51465182/how-to-remove-index-signature-using-mapped-types/51956054#51956054}
 */
export type ObjectNamedKeys<Target> = keyof {
  [Key in keyof Target as string extends Key
    ? never
    : number extends Key
      ? never
      : symbol extends Key
        ? never
        : Key]: Target[Key]
}
export type ObjectNamedParts<Target> = ObjectPrettify<Pick<Target, ObjectNamedKeys<Target>>>
export type ObjectIndexedParts<Target> = ObjectPrettify<Omit<Target, ObjectNamedKeys<Target>>>
export type ObjectHasNamedKeys<Target> = ObjectNamedKeys<Target> extends never ? false : true
export type ObjectHasIndexedKeys<Target> = keyof ObjectIndexedParts<Target> extends never
  ? false
  : true

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

/**
 * @example
 *   ```
 *   interface Temp { a: string, b: number, c?: boolean }
 *   // Expect: { a: string | undefined, b: number, c?: boolean }
 *   type Example1 = UndefinedableByKeys<Temp, 'a'>
 *   ```
 */
export type UndefinedableByKeys<Target, Keys> = {
  [Key in keyof Target]: Key extends Keys ? Undefinedable<Target[Key]> : Target[Key]
}
export type UndefinedableAllKeys<Target> = UndefinedableByKeys<Target, keyof Target>

/**
 * @example
 *   ```
 *   interface Temp { a: string, b: number, c?: boolean }
 *   // Expect: { a: string | null, b: number, c?: boolean }
 *   type Example1 = NullableByKeys<Temp, 'a'>
 *   ```
 */
export type NullableByKeys<Target, Keys> = {
  [Key in keyof Target]: Key extends Keys ? Nullable<Target[Key]> : Target[Key]
}
export type NullableAllKeys<Target> = NullableByKeys<Target, keyof Target>

/**
 * @example
 *   ```
 *   interface Temp { a: string, b: number, c?: boolean }
 *   // Expect: { a: string | null | undefined, b: number, c?: boolean }
 *   type Example1 = NilableByKeys<Temp, 'a'>
 *   ```
 */
export type NilableByKeys<Target, Keys> = {
  [Key in keyof Target]: Key extends Keys ? Nilable<Target[Key]> : Target[Key]
}
export type NilableAllKeys<Target> = NilableByKeys<Target, keyof Target>

/**
 * @example
 *   ```
 *   interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example1 = NonUndefinedableAllKeys<Temp>
 *   ```
 */
export type NonUndefinedableAllKeys<Target> = {
  [Key in keyof Target]: NonUndefinedable<Target[Key]>
}
/**
 * @example
 *   ```
 *   interface Temp { a: string | undefined, b: number, c?: boolean }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example1 = NonUndefinedableByKeys<Temp, 'a'>
 *   type Example2 = NonUndefinedableByKeys<Temp, 'a' | 'b'>
 *
 *   interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example3 = NonUndefinedableByKeys<Temp, 'a' | 'c'>
 *   // Expect: { a: string | undefined, b: number, c?: boolean }
 *   type Example4 = NonUndefinedableByKeys<Temp, 'c'>
 *   ```
 */
export type NonUndefinedableByKeys<Target, Keys> = ObjectPrettify<
  NonUndefinedableAllKeys<Pick<Target, UnionIntersection<RequiredKeys<Target>, Keys>>> &
    Pick<Target, UnionDifference<RequiredKeys<Target>, Keys>> &
    Partial<NonUndefinedableAllKeys<Pick<Target, UnionIntersection<OptionalKeys<Target>, Keys>>>> &
    Pick<Target, UnionDifference<OptionalKeys<Target>, Keys>>
>

/**
 * @example
 *   ```
 *   interface Temp { a: string | null, b: number, c?: boolean | null }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example1 = NonNullableAllKeys<Temp>
 *   ```
 */
export type NonNullableAllKeys<Target> = {
  [Key in keyof Target]: NonNullable<Target[Key]>
}
/**
 * @example
 *   ```
 *   interface Temp { a: string | null, b: number, c?: boolean }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example1 = NonNullableByKeys<Temp, 'a'>
 *   type Example2 = NonNullableByKeys<Temp, 'a' | 'b'>
 *
 *   interface Temp { a: string | null, b: number, c?: boolean | null }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example3 = NonNullableByKeys<Temp, 'a' | 'c'>
 *   // Expect: { a: string | null, b: number, c?: boolean }
 *   type Example4 = NonNullableByKeys<Temp, 'c'>
 *   ```
 */
export type NonNullableByKeys<Target, Keys> = ObjectPrettify<
  NonNullableAllKeys<Pick<Target, UnionIntersection<RequiredKeys<Target>, Keys>>> &
    Pick<Target, UnionDifference<RequiredKeys<Target>, Keys>> &
    Partial<NonNullableAllKeys<Pick<Target, UnionIntersection<OptionalKeys<Target>, Keys>>>> &
    Pick<Target, UnionDifference<OptionalKeys<Target>, Keys>>
>

/**
 * @example
 *   ```
 *   interface Temp { a: string | null | undefined, b: number, c?: boolean | null }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example1 = NonNilableAllKeys<Temp>
 *   ```
 */
export type NonNilableAllKeys<Target> = {
  [Key in keyof Target]: NonNilable<Target[Key]>
}
/**
 * @example
 *   ```
 *   interface Temp { a: string | null | undefined, b: number, c?: boolean }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example1 = NonNilableByKeys<Temp, 'a'>
 *   type Example2 = NonNilableByKeys<Temp, 'a' | 'b'>
 *
 *   interface Temp { a: string | null | undefined, b: number, c?: boolean | null | undefined }
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example3 = NonNilableByKeys<Temp, 'a' | 'c'>
 *   // Expect: { a: string | null | undefined, b: number, c?: boolean }
 *   type Example4 = NonNilableByKeys<Temp, 'c'>
 *   ```
 */
export type NonNilableByKeys<Target, Keys> = ObjectPrettify<
  NonNilableAllKeys<Pick<Target, UnionIntersection<RequiredKeys<Target>, Keys>>> &
    Pick<Target, UnionDifference<RequiredKeys<Target>, Keys>> &
    Partial<NonNilableAllKeys<Pick<Target, UnionIntersection<OptionalKeys<Target>, Keys>>>> &
    Pick<Target, UnionDifference<OptionalKeys<Target>, Keys>>
>

/**
 * @example
 *   ```
 *   interface Temp { a?: string | undefined, b?: number, c?: boolean }
 *   // Expect: { readonly a: string | undefined, readonly b: number, readonly c: boolean }
 *   type Example1 = ReadonlyAllKeys<Temp>
 *   ```
 */
export type ReadonlyAllKeys<Target> = {
  +readonly [Key in keyof Target]: Target[Key]
}
/**
 * @example
 *   ```
 *   interface Temp { a?: string | undefined, b?: number, c?: boolean }
 *   // Expect: { readonly a: string | undefined, readonly b: number, readonly c: boolean }
 *   type Example1 = ReadonlyByKeys<Temp, 'a' | 'b' | 'c'>
 *   ```
 */
export type ReadonlyByKeys<Target, Keys> = ObjectPrettify<
  ReadonlyAllKeys<Pick<Target, UnionIntersection<keyof Target, Keys>>> &
    Pick<Target, UnionDifference<keyof Target, Keys>>
>

/**
 * @example
 *   ```
 *   interface Temp { readonly a?: string | undefined, readonly b?: number, readonly c?: boolean }
 *   // Expect: { a: string | undefined, b: number, c: boolean }
 *   type Example1 = WritableAllKeys<Temp>
 *   ```
 */
export type WritableAllKeys<Target> = {
  -readonly [Key in keyof Target]: Target[Key]
}
/**
 * @example
 *   ```
 *   interface Temp { readonly a?: string | undefined, readonly b?: number, readonly c?: boolean }
 *   // Expect: { a: string | undefined, b: number, c: boolean }
 *   type Example1 = WritableByKeys<Temp, 'a' | 'b' | 'c'>
 *   ```
 */
export type WritableByKeys<Target, Keys> = ObjectPrettify<
  WritableAllKeys<Pick<Target, UnionIntersection<keyof Target, Keys>>> &
    Pick<Target, UnionDifference<keyof Target, Keys>>
>

/**
 * @example
 *   ```
 *   interface Temp { a?: string | undefined, b?: number, c?: boolean }
 *   // Expect: { a: string | undefined, b: number, c: boolean }
 *   type Example1 = RequiredAllKeys<Temp>
 *   ```
 */
export type RequiredAllKeys<Target> = {
  [Key in keyof Target]-?: Target[Key]
}
/**
 * @example
 *   ```
 *    interface Temp { a?: string | undefined, b?: number, c?: boolean }
 *    // Expect: { a: string | undefined, b: number, c: boolean }
 *    type Example1 = RequiredByKeys<Temp, 'a' | 'b' | 'c'>
 *   ```
 */
export type RequiredByKeys<Target, Keys> = ObjectPrettify<
  RequiredAllKeys<Pick<Target, UnionIntersection<keyof Target, Keys>>> &
    Pick<Target, UnionDifference<keyof Target, Keys>>
>

/**
 * @example
 *   ```
 *   interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
 *   // Expect: { a?: string | undefined, b?: number, c?: boolean | undefined }
 *   type Example1 = OptionalAllKeys<Temp>
 *   ```
 */
export type OptionalAllKeys<Target> = {
  [Key in keyof Target]+?: Target[Key]
}
/**
 * @example
 *   ```
 *   interface Temp { a: string | undefined, b: number, c?: boolean | undefined }
 *   // Expect: { a?: string | undefined, b?: number, c?: boolean }
 *   type Example1 = OptionalByKeys<Temp, 'a' | 'b' | 'c'>
 *   ```
 */
export type OptionalByKeys<Target, Keys> = ObjectPrettify<
  OptionalAllKeys<Pick<Target, UnionIntersection<keyof Target, Keys>>> &
    Pick<Target, UnionDifference<keyof Target, Keys>>
>

/**
 * @description Given a type `{ a?: string, b: number }`, return `{ a: string, b?: number }`.
 *
 * @example
 *   ```
 *   interface Temp { a: string, b?: number, c?: boolean }
 *   // Expect: { a?: string, b: number, c: boolean }
 *   type Example1 = ReverseOptional<Temp>
 *   ```
 *
 * @see {@link ReverseRequired}
 * @see {@link https://stackoverflow.com/questions/57593022/reverse-required-and-optional-properties}
 */
export type ReverseOptional<Target> = ObjectPrettify<
  Required<Pick<Target, OptionalKeys<Target>>> & OptionalAllKeys<Omit<Target, OptionalKeys<Target>>>
>
/**
 * @see {@link ReverseOptional}
 */
export type ReverseRequired<Target> = ReverseOptional<Target>

/**
 * @example
 *   ```
 *   interface Temp { a: string, b?: number, c?: boolean }
 *
 *   // Expect: { a: string, b: number, c?: boolean }
 *   type Example1 = ReverseOptionalByKeys<Temp, 'b'>
 *   ```
 */
export type ReverseOptionalByKeys<Target, Keys extends keyof Target> = ObjectPrettify<
  Omit<Target, Keys> & ReverseOptional<Pick<Target, Keys>>
>
/**
 * @see {@link ReverseOptionalByKeys}
 */
export type ReverseRequiredByKeys<Target, Keys extends keyof Target> = ReverseOptionalByKeys<
  Target,
  Keys
>

/**
 * @example
 *   ```
 *   type Props = { name: string; age: number; visible: boolean };
 *   type DefaultProps = { age: number };
 *   // Expect: { age: number; }
 *   type Example1 = ObjectIntersection<Props, DefaultProps>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type ObjectIntersection<T extends AnyHybridRecord, U extends AnyHybridRecord> = Pick<
  T,
  UnionIntersection<keyof T, keyof U>
>

/**
 * @example
 *   ```
 *   type Props = { name: string; age: number; visible: boolean };
 *   type DefaultProps = { age: number };
 *   // Expect: { name: string; visible: boolean; }
 *   type Example1 = ObjectDifference<Props, DefaultProps>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type ObjectDifference<T extends AnyHybridRecord, U extends AnyHybridRecord> = Pick<
  T,
  UnionDifference<keyof T, keyof U>
>

/**
 * @example
 *   ```
 *   type Props = { name: string; age: number; visible: boolean };
 *   type DefaultProps = { age: number };
 *   // Expect: { name: string; visible: boolean; }
 *   type Example1 = ObjectComplement<Props, DefaultProps>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type ObjectComplement<T extends SuperT, SuperT extends AnyHybridRecord> = Pick<
  T,
  UnionComplement<keyof T, keyof SuperT>
>

/**
 * @example
 *   ```
 *   interface PropsA { name: string, age: number, visible: boolean }
 *   interface PropsB { age: number, sex: string }
 *   // Expect: { name: string; visible: boolean; sex: string };
 *   type Example1 = ObjectSymmetricDifference<PropsA, PropsB>
 *   // Expect: 'name' | 'visible' | 'sex'
 *   type Example2 = keyof ObjectSymmetricDifference<PropsA, PropsB>
 *   ```
 */
export type ObjectSymmetricDifference<
  T extends AnyHybridRecord,
  U extends AnyHybridRecord,
> = ObjectPrettify<ObjectDifference<T, U> & ObjectDifference<U, T>>

/**
 * @example
 *   ```
 *   interface Props { name: string, age: number, visible: boolean }
 *   interface NewProps { age: string, other: string }
 *   // Expect: { name: string; age: string; visible: boolean; }
 *   type Example1 = ObjectOverwrite<Props, NewProps>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type ObjectOverwrite<
  Target extends AnyHybridRecord,
  Patch extends AnyHybridRecord,
> = ObjectPrettify<ObjectDifference<Target, Patch> & ObjectIntersection<Patch, Target>>

/**
 * @example
 *   ```
 *   interface Props { name: string, age: number, visible: boolean }
 *   interface NewProps { age: string, other: string }
 *   // Expect: { name: string; age: string; visible: boolean; other: string; }
 *   type Example1 = ObjectAssign<Props, NewProps>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type ObjectAssign<
  Target extends AnyHybridRecord,
  Patch extends AnyHybridRecord,
> = ObjectPrettify<
  // ObjectDifference<Target, Patch> & ObjectIntersection<Patch, Target> & ObjectDifference<Patch, Target>
  Omit<Target, keyof Patch> & Patch
>
/**
 * @description Alias for `ObjectAssign`, defined for semantic of `ObjectMergeN`.
 *
 * @see {@link ObjectAssign}
 */
export type ObjectMerge<
  Target extends AnyHybridRecord,
  Patch extends AnyHybridRecord,
> = ObjectAssign<Target, Patch>

type InternalObjectMergeN<
  Targets extends AnyHybridRecord[],
  Result extends AnyHybridRecord,
> = Targets extends [infer Head, ...infer Tail]
  ? InternalObjectMergeN<
      Tail extends AnyHybridRecord[] ? Tail : [],
      ObjectMerge<Result, Head extends AnyHybridRecord ? Head : {}>
    >
  : Result
/**
 * @example
 *   ```
 *   interface a { a: string }
 *   interface b { readonly b: string }
 *   interface c { c?: string }
 *   // Expect: { a: string; readonly b: string; c?: string; }
 *   type Example1 = ObjectMergeN<[a, b, c]>
 *   ```
 */
export type ObjectMergeN<Targets extends AnyHybridRecord[]> = ObjectPrettify<
  InternalObjectMergeN<Targets, {}>
>

/**
 * @example
 *   ```
 *   interface Props { name: string, age: number, visible: boolean }
 *   // Expect: { name: string; } | { age: number; } | { visible: boolean; }
 *   type UnionizedType = ObjectUnionize<Props>
 *   ```
 *
 * @see {@link https://github.com/piotrwitek/utility-types/blob/master/src/mapped-types.ts}
 */
export type ObjectUnionize<Target extends AnyHybridRecord> = {
  [Key in keyof Target]: { [Q in Key]: Target[Key] }
}[keyof Target]

/**
 * @example
 *   ```
 *   interface Temp {
 *     readonly grandpa: {
 *       readonly name: string
 *       father?: {
 *         readonly name?: string
 *         son: {
 *           readonly name?: string
 *         }
 *       }
 *     }
 *   }
 *   // Expect: { grandpa?: { name?: string, father?: { name?: string, son?: { name?: string } } } }
 *   type Example1 = ObjectDeepWritable<Temp>
 *   ```
 */
export type ObjectDeepWritable<Target extends AnyStringRecord> = {
  -readonly [Key in keyof Target]: Target[Key] extends AnyStringRecord | undefined
    ? ObjectDeepWritable<NonUndefinedable<Target[Key]>>
    : Target[Key]
}

/**
 * @example
 *   ```
 *   interface Temp {
 *     grandpa: {
 *       name: string
 *       father?: {
 *         name?: string
 *         son: {
 *           name?: string
 *         }
 *       }
 *     }
 *   }
 *   // Expect: { readonly grandpa?: {
 *   //             readonly name?: string, readonly father?: { readonly name?: string, readonly son?: { readonly name?: string } }
 *   //         } }
 *   type Example1 = ObjectDeepReadonly<Temp>
 *   ```
 */
export type ObjectDeepReadonly<Target extends AnyStringRecord> = {
  +readonly [Key in keyof Target]: Target[Key] extends AnyStringRecord | undefined
    ? ObjectDeepReadonly<NonUndefinedable<Target[Key]>>
    : Target[Key]
}

/**
 * @example
 *   ```
 *   interface Temp {
 *     grandpa: {
 *       name: string
 *       father?: {
 *         name?: string
 *         son: {
 *           name?: string
 *         }
 *       }
 *     }
 *   }
 *   // Expect: { grandpa: { name: string, father: { name: string, son: { name: string } } } }
 *   type Example1 = ObjectDeepRequired<Temp>
 *   ```
 */
export type ObjectDeepRequired<Target extends AnyStringRecord> = {
  [Key in keyof Target]-?: Target[Key] extends AnyStringRecord | undefined
    ? ObjectDeepRequired<NonUndefinedable<Target[Key]>>
    : Target[Key]
}

/**
 * @example
 *   ```
 *   interface Temp {
 *     grandpa: {
 *       name: string
 *       father?: {
 *         name?: string
 *         son: {
 *           name?: string
 *         }
 *       }
 *     }
 *   }
 *   // Expect: { grandpa?: { name?: string, father?: { name?: string, son?: { name?: string } } } }
 *   type Example1 = ObjectDeepOptional<Temp>
 *   ```
 */
export type ObjectDeepOptional<Target extends AnyStringRecord> = {
  [Key in keyof Target]+?: Target[Key] extends AnyStringRecord | undefined
    ? ObjectDeepOptional<NonUndefinedable<Target[Key]>>
    : Target[Key]
}

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

/**
 * @description Extract method signature as a standalone function.
 *
 * @example
 *   ```
 *   type Obj = { method(a: number, b: string): boolean }
 *   // Expect: (a: number, b: string) => boolean
 *   type Example1 = ObjectToFunction<Obj, 'method'>
 *   ```
 */
export type ObjectToFunction<T, Key extends keyof T> = T[Key] extends (...args: infer P) => infer R
  ? (...args: P) => R
  : never