/* eslint-disable @typescript-eslint/no-explicit-any */
import { Nullable } from "./helpers.types";
import { JoinString } from "./string.types";

export type ObjectType<T = any, P extends PropertyKey = PropertyKey> = Record<P, T>;

export type EmptyObjectType = ObjectType<never>;

export type StringDictionary<T> = ObjectType<T, string>;

export type NumericDictionary<T> = ObjectType<T, number>;

export type UnionToObject<T extends string> = ObjectType<never, T>;

export type PickUnion<T extends string, K extends keyof UnionToObject<T>> = keyof Pick<UnionToObject<T>, K>;

export type OmitUnion<T extends string, K extends keyof UnionToObject<T>> = keyof Omit<UnionToObject<T>, K>;

export type PartialBy<T extends Record<string, unknown>, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

export type PartialKeys<T extends Record<string, unknown>> = {
  [K in keyof T]?: Partial<T[K]>;
};

export type NonNullableKeys<T> = {
  [P in keyof T]-?: NonNullable<T[P]>;
};

export type NullableKeys<T> = {
  [K in keyof T]: Nullable<T[K]>;
};

export type OptionalKeys<T> = {
  [K in keyof T]?: T[K];
};

type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...0[]];

export type PathsOf<T, S extends string = ".", D extends number = 5> = [D] extends [never]
  ? never
  : T extends object
    ? {
        [K in keyof T]-?: K extends string | number ? `${K}` | JoinString<K, PathsOf<T[K], S, Prev[D]>, S> : never;
      }[keyof T]
    : "";

export type LeavesOf<T, S extends string = ".", D extends number = 5> = [D] extends [never]
  ? never
  : T extends object
    ? { [K in keyof T]-?: JoinString<K, LeavesOf<T[K], S, Prev[D]>, S> }[keyof T]
    : "";

export type ObjectPathToValue<
  Values extends ObjectType,
  P extends string,
  S extends string = ".",
> = P extends `${infer Left}${S}${infer Rest}`
  ? Rest extends PathsOf<Values[Left]>
    ? ObjectPathToValue<Values[Left], Rest, S>
    : never
  : Values[P];

export type RequiredKeys<T> = {
  [K in keyof T]-?: Exclude<T[K], undefined | null>;
};
// Names of properties in T with types that include undefined
export type OptionalPropertyNames<T> = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T];

// Common properties from L and R with undefined in R[K] replaced by type in L[K]
type SpreadProperties<L, R, K extends keyof L & keyof R> = { [P in K]: L[P] | Exclude<R[P], undefined> };

// is an identity type and in principle shouldn't do anything to the type
type Id<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;

// Type of { ...L, ...R }
export type Spread<L, R> = Id<
  // Properties in L that don't exist in R
  Pick<L, Exclude<keyof L, keyof R>> &
    // Properties in R with types that exclude undefined
    Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> &
    // Properties in R, with types that include undefined, that don't exist in L
    Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> &
    // Properties in R, with types that include undefined, that exist in L
    SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>
>;