import { Postgres } from "packages/store/index";
import type { PendingQuery } from "postgres";

export type QueryPartArg =
  | string
  | boolean
  | number
  | null
  | undefined
  | Date
  | QueryPart
  | QueryPartArg[];

export interface QueryPart<T = any> {
  get strings(): string[];

  get values(): QueryPartArg[];

  append(query: QueryPart): QueryPart<T>;

  exec(sql: Postgres): PendingQuery<T>;
}

/**
 * Wrap query builder results
 */
export type WrappedQueryPart<Type = any> = {
  /**
   * Get the underlying queryPart, representing the build query
   */
  queryPart: QueryPart;

  /**
   * @deprecated Use `.exec` or `.execRaw`
   */
  then(): never;

  /**
   * Exec the query and return validated query results.
   */
  exec(sql: Postgres): Promise<Type[]>;

  /**
   * Exec the query and return raw query results. This should be used when a custom 'select'
   * or 'returning' is used.
   */
  execRaw(sql: Postgres): Promise<Partial<Type>[]>;
};

/**
 * Wrap query builder results
 */
export type WrappedQueryResult<Type = any> = {
  /**
   * Get the underlying queryPart, representing the build query
   */
  queryPart: QueryPart;

  /**
   * @deprecated Use `.exec` or `.execRaw`
   */
  then(): never;

  /**
   * Exec the query and return validated query results.
   */
  exec(sql: Postgres): Promise<Type[]>;

  /**
   * Exec the query and return raw query results. This should be used when a custom 'select'
   * or 'returning' is used.
   */
  execRaw(sql: Postgres): Promise<Type[]>;
};

// ------ QueryBuilder Type Resolver ------

/**
 * Utility type to resolve the full type instead of showing things like `Omit<Type,
 * SomeNesting<...>> & ...` in the type popups and errors.
 */
type _ResolveType<T> = { [K in keyof T]: T[K] } & {};

/**
 * Utility type to resolve the base + expansion of an entity.
 */
export type QueryBuilderDefinition<Base, Expansion> = {
  base: Base;
  expansion: Expansion;
};

type PickKeysThatExtend<T, Select> = {
  [K in keyof T as T[K] extends Select ? K : never]: T[K];
};

type OmitKeysThatExtend<T, Select> = {
  [K in keyof T as T[K] extends Select ? never : K]: T[K];
};

/**
 * Omit never values
 */
type OmitNever<T> = OmitKeysThatExtend<T, never>;

/**
 * Apply Partial if the type can be undefined.
 */
type ConvertUndefinedToPartial<T> = {
	[K in keyof T as undefined extends T[K] ? K : never] ?: T[K];
} & {
	[K in keyof T as undefined extends T[K] ? never : K]: T[K];
};

type QueryBuilderSpecialKeys =
  | "offset"
  | "limit"
  | "orderBy"
  | "orderBySpec"
  | "select"
  | "where";

/**
 * Max value for which optional joins are resolved.
 */
type ResolveJoinDepth = 6;

/**
 * Provided an QueryBuilder expansion object, determines the union of all possible joins up
 * until {@link ResolveJoinDepth} depth.
 */
export type ResolveOptionalJoins<
  Expansion,
  Prefix extends string = "",
  Depth extends Array<unknown> = [],
> = Depth["length"] extends ResolveJoinDepth
  ? never
  : Expansion extends {
        expansion: unknown;
      }
    ? ResolveOptionalJoins<Expansion["expansion"], Prefix, Depth>
    : Expansion extends Array<{
          expansion: unknown;
        }>
      ? ResolveOptionalJoins<Expansion[0]["expansion"], Prefix, Depth>
      : Expansion extends object
        ? {
            [K in keyof Expansion]: K extends string
              ? Prefix extends "" // Base case
                ?
                    | `${K}`
                    | ResolveOptionalJoins<
                        Expansion[K],
                        `${K}`,
                        [unknown, ...Depth]
                      >
                : // Nested case
                  | `${Prefix}.${K}` // Recursive into other expansions.
                    | ResolveOptionalJoins<
                        Expansion[K],
                        `${Prefix}.${K}`,
                        [unknown, ...Depth]
                      >
              : never;
          }[keyof Expansion]
        : never;

/**
 * Split the input string on the first '.'-char.
 */
type SplitDot<Input extends string> = Input extends `${infer Start}.${string}`
  ? Start
  : never;

/**
 * Check if the provided key is in one of the optional joins. This is also true when the key
 * is a prefix of a join. i.e `settings` is optional if `settings.user` is an optional join.
 */
type IsOptionalJoin<
  Key extends string,
  Joins extends string,
> = Key extends Joins ? true : Key extends SplitDot<Joins> ? true : false;

/**
 * Filters and strips the Joins that start with Prefix.
 */
type FilterOptionalJoins<Joins extends string, Prefix extends string> = {
  [K in Joins]: K extends `${Prefix}`
    ? never
    : K extends `${Prefix}.${infer Suffix}`
      ? Suffix
      : never;
}[Joins];

/**
 * Pick the selected fields from the Type.
 * If no select field exists on the builder, or if "*" is supplied, the full Type is returned.
 */
type PickSelected<Type, SelectBuilder> = SelectBuilder extends {
  select: "*" | Array<string>;
}
  ? SelectBuilder["select"] extends "*" // Select all fields
    ? Type
    : SelectBuilder["select"] extends Array<infer K extends keyof Type> // Only select the fields
      ? // that have been selected.
        Pick<Type, K>
      : never // Defaults to selecting all fields.
  :
    Type;

type ResolveBaseResult<
  Base,
  QueryBuilder,
  OptionalJoins extends string,
> = OmitNever<
	ConvertUndefinedToPartial<
		PickSelected<
  		Omit<
    		Base,
    		Exclude<keyof QueryBuilder, QueryBuilderSpecialKeys> | OptionalJoins
  		>,
  		QueryBuilder
		>
	>
>;

type ResolveTypeFromExpansion<
  DefinitionType,
  QueryBuilder,
  OptionalJoins extends string,
> =
  DefinitionType extends Array<infer SingleDefinition>
    ? Array<QueryBuilderResolver<SingleDefinition, QueryBuilder, OptionalJoins>>
    : QueryBuilderResolver<DefinitionType, QueryBuilder, OptionalJoins>;

type ResolveExpansionKey<
  K extends keyof Expansion & string,
  Base,
  Expansion,
  QueryBuilder,
  OptionalJoins extends string,
> = K extends keyof QueryBuilder
  ? ResolveTypeFromExpansion<
      Expansion[K],
      QueryBuilder[K],
      FilterOptionalJoins<OptionalJoins, K>
    >
  : IsOptionalJoin<K, OptionalJoins> extends true
    ? K extends keyof Base
      ? // We need to include the base type if it exists for owning sides of relations.
        | ResolveTypeFromExpansion<
              Expansion[K],
              unknown,
              FilterOptionalJoins<OptionalJoins, K>
            >
          | Base[K]
          | undefined
      :
          | ResolveTypeFromExpansion<
              Expansion[K],
              unknown,
              FilterOptionalJoins<OptionalJoins, K>
            >
          | undefined
    : K extends keyof Base
      ? Base[K]
      : never;

/**
 * Provided a Definition and a QueryBuilder, resolves the return type.
 *
 * For usage of this type in  function parameter definitions, OptionalJoins can be supplied.
 */
export type QueryBuilderResolver<
  DefinitionType,
  QueryBuilder,
  OptionalJoins extends string = "",
> =
  DefinitionType extends QueryBuilderDefinition<infer Base, infer Expansion>
    ? _ResolveType<
        ResolveBaseResult<Base, QueryBuilder, OptionalJoins> &
					OmitNever<
						ConvertUndefinedToPartial<
							_ResolveType<{
								[K in Exclude<
									Exclude<keyof Expansion, QueryBuilderSpecialKeys>,
									number | symbol
								>]: _ResolveType<
									ResolveExpansionKey<
										K,
										Base,
										Expansion,
										QueryBuilder,
										OptionalJoins
									>
								>;
							}>
						>
					>
      >
    : DefinitionType extends undefined ? undefined : never;