/**
 * This module exports modified versions of the GraphQL types from the `graphql`
 * package that add more type-safety but are still at runtime exactly the same
 * as the original types. Some of the constructors
 *
 * @module
 */
import {
  GraphQLArgumentExtensions,
  GraphQLEnumType,
  type GraphQLEnumTypeConfig,
  type GraphQLEnumValueConfig,
  GraphQLFieldExtensions,
  GraphQLInputField,
  GraphQLInputFieldExtensions,
  GraphQLInputObjectType,
  type GraphQLInputObjectTypeConfig,
  GraphQLInterfaceType,
  GraphQLInterfaceTypeConfig,
  GraphQLList,
  GraphQLNonNull,
  GraphQLObjectType,
  GraphQLObjectTypeConfig,
  GraphQLResolveInfo,
  GraphQLScalarType,
  type GraphQLTypeResolver,
  GraphQLUnionType,
  type GraphQLUnionTypeConfig,
  type FieldDefinitionNode,
  type InputValueDefinitionNode,
} from "graphql";
import type { g } from "./g-for-doc-references.js";

type Maybe<T> = T | null | undefined;

export type GNullableOutputType<Context> =
  | GScalarType
  | GObjectType<any, Context>
  | GInterfaceType<any, any, Context>
  | GUnionType<any, Context>
  | GEnumType<Record<string, unknown>>
  | GList<GOutputType<Context>>;

export type GOutputType<Context> =
  | GNullableOutputType<Context>
  | GNonNull<GNullableOutputType<Context>>;

export type GNullableInputType =
  | GScalarType
  | GEnumType<Record<string, unknown>>
  | GInputObjectType<any, boolean>
  | GList<GInputType>;

export type GInputType = GNullableInputType | GNonNull<GNullableInputType>;

export type GNullableType<Context> =
  | GNullableOutputType<Context>
  | GNullableInputType;

export type GType<Context> = GOutputType<Context> | GInputType;

export type GFieldResolver<
  Source,
  Args extends Record<string, GArg<GInputType>>,
  Type extends GOutputType<Context>,
  Context,
> = (
  source: Source,
  args: InferValueFromArgs<Args>,
  context: Context,
  info: GraphQLResolveInfo
) => InferValueFromOutputType<Type>;

type InferValueFromOutputTypeWithoutAddingNull<Type extends GOutputType<any>> =
  Type extends GraphQLScalarType<infer Value>
    ? Value
    : Type extends GraphQLEnumType
      ? Type extends GEnumType<infer Values>
        ? Values[keyof Values]
        : never
      : Type extends GList<infer Value extends GOutputType<any>>
        ? // the `object` bit is here because graphql checks `typeof maybeIterable === 'object'`
          // which means that things like `string` won't be allowed
          // (which is probably a good thing because returning a string from a resolver that needs
          // a graphql list of strings is almost definitely not what you want and if it is, use Array.from)
          // sadly functions that are iterables will be allowed by this type but not allowed by graphql-js
          // (though tbh, i think the chance of that causing problems is quite low)
          object & Iterable<InferValueFromOutputType<Value>>
        : Type extends GraphQLObjectType<infer Source, any>
          ? Source
          : Type extends GraphQLUnionType | GraphQLInterfaceType
            ? Type extends
                | GUnionType<infer Source, any>
                | GInterfaceType<infer Source, any, any>
              ? Source
              : unknown
            : never;

export type InferValueFromOutputType<Type extends GOutputType<any>> =
  MaybePromise<
    Type extends GNonNull<infer Value extends GNullableOutputType<any>>
      ? InferValueFromOutputTypeWithoutAddingNull<Value>
      : InferValueFromOutputTypeWithoutAddingNull<Type> | null | undefined
  >;

type MaybePromise<T> = Promise<T> | T;

type InferValueFromNullableInputType<Type extends GInputType> =
  Type extends GraphQLScalarType<infer Value, any>
    ? Value
    : Type extends GraphQLEnumType
      ? Type extends GEnumType<infer Values>
        ? Values[keyof Values]
        : unknown
      : Type extends GList<infer Value extends GInputType>
        ? InferValueFromInputType<Value>[]
        : Type extends GraphQLInputObjectType
          ? Type extends GInputObjectType<infer Fields, infer IsOneOf>
            ? IsOneOf extends true
              ? InferValueForOneOf<Fields>
              : InferValueFromArgs<Fields>
            : Record<string, unknown>
          : never;

type InferValueForOneOf<
  T extends { [key: string]: { type: GInputType } },
  Key extends keyof T = keyof T,
> = Flatten<
  Key extends unknown
    ? {
        readonly [K in Key]: InferValueFromNullableInputType<T[K]["type"]>;
      } & {
        readonly [K in Exclude<keyof T, Key>]?: never;
      }
    : never
>;

export type InferValueFromArgs<Args extends Record<string, GArg<GInputType>>> =
  {
    readonly [Key in keyof Args]: InferValueFromArg<Args[Key]>;
  } & {};

export type InferValueFromArg<Arg extends GArg<GInputType>> =
  // the distribution technically only needs to be around the AddUndefined
  // but having it here instead of inside the union
  // means that TypeScript will print the resulting type
  // when you use it rather than keep the alias and
  // the resulting type is generally far more readable
  Arg extends unknown
    ?
        | InferValueFromInputType<Arg["type"]>
        | AddUndefined<Arg["type"], Arg["defaultValue"]>
    : never;

type AddUndefined<TInputType extends GInputType, DefaultValue> =
  TInputType extends GNonNull<any> ? never : DefaultValue & undefined;

export type InferValueFromInputType<Type extends GInputType> =
  Type extends GNonNull<infer Value extends GNullableInputType>
    ? InferValueFromNullableInputType<Value>
    : InferValueFromNullableInputType<Type> | null;

/**
 * A GraphQL output field for an {@link GObjectType object type} which should be
 * created using {@link g.field}.
 */
export type GField<
  Source,
  Args extends { [Key in keyof Args]: GArg<GInputType> },
  Type extends GOutputType<Context>,
  SourceAtKey,
  Context,
> = {
  args?: Args;
  type: Type;
  resolve?: GFieldResolver<Source, Args, Type, Context>;
  description?: Maybe<string>;
  deprecationReason?: Maybe<string>;
  extensions?: Maybe<Readonly<GraphQLFieldExtensions<any, Context>>>;
  astNode?: Maybe<FieldDefinitionNode>;
  __missingResolve: undefined | ((arg: SourceAtKey) => void);
};

/**
 * A GraphQL object type. This should generally be constructed with
 * {@link g.object}.
 *
 * Note this is an **output** type, if you want an input object, use
 * {@link GInputObjectType}.
 *
 * If you use the `GObjectType` constructor directly, all fields will need
 * explicit resolvers so you should use `g.object` instead.
 */
export class GObjectType<Source, Context> extends GraphQLObjectType<
  Source,
  Context
> {
  constructor(
    config: Readonly<
      GObjectTypeConfig<
        Source,
        Context,
        Record<string, GField<Source, any, any, unknown, Context>>,
        readonly GInterfaceType<Source, any, Context>[]
      >
    >
  );
}

export type GObjectTypeConfig<
  Source,
  Context,
  Fields extends Record<string, GField<Source, any, any, any, Context>>,
  Interfaces extends readonly GInterfaceType<Source, any, Context>[],
> = {
  fields: Fields | (() => Fields);
  interfaces?: [...Interfaces];
} & Omit<GraphQLObjectTypeConfig<Source, Context>, "fields" | "interfaces">;

/**
 * A GraphQL union type. This should generally be constructed with
 * {@link g.union}.
 *
 * A union type represents an object that could be one of a list of types. Note
 * it is similar to an {@link GInterfaceType} except that a union doesn't imply
 * having a common set of fields among the member types.
 *
 * While this constructor will work, you should generally use `g.union` because
 * you will need to explicitly provide the source type parameter as TypeScript
 * is unable to infer it correctly. Note this is only required for this
 * constructor, this is not required when using `g.union`.
 */
export class GUnionType<Source, Context> extends GraphQLUnionType {
  constructor(
    config: Readonly<
      GUnionTypeConfig<
        Source extends any ? GObjectType<Source, Context> : never,
        Context
      >
    >
  );
  resolveType: Maybe<GraphQLTypeResolver<Source, Context>>;
}

export type GUnionTypeConfig<
  ObjectType extends GObjectType<any, Context>,
  Context,
> = Flatten<
  {
    types: readonly ObjectType[] | (() => readonly ObjectType[]);
  } & Omit<
    GraphQLUnionTypeConfig<
      ObjectType extends GObjectType<infer Source, Context> ? Source : never,
      Context
    >,
    "types"
  >
>;

export type GInterfaceField<
  Args extends Record<string, GArg<GInputType>>,
  Type extends GOutputType<Context>,
  Context,
> = {
  description?: Maybe<string>;
  type: Type;
  args?: Args;
  deprecationReason?: Maybe<string>;
  extensions?: Maybe<Readonly<GraphQLFieldExtensions<any, Context>>>;
  astNode?: Maybe<FieldDefinitionNode>;
};

/**
 * A GraphQL interface type that can be implemented by other
 * {@link GObjectType GraphQL object} and interface types. This should generally
 * be constructed with {@link g.interface}.
 *
 * If you use the `GInterfaceType` constructor directly, all fields will need
 * explicit resolvers so you should use `g.interface` instead.
 */
export class GInterfaceType<
  Source,
  Fields extends Record<
    string,
    GInterfaceField<any, GOutputType<Context>, Context>
  >,
  Context,
> extends GraphQLInterfaceType {
  declare resolveType: Maybe<GraphQLTypeResolver<Source, Context>>;
  constructor(
    config: Readonly<
      GInterfaceTypeConfig<
        Source,
        Fields,
        readonly GInterfaceType<Source, {}, Context>[],
        Context
      >
    >
  );
  toConfig(): Omit<ReturnType<GraphQLInterfaceType["toConfig"]>, "fields"> & {
    fields: Fields;
  };
}

export type GInterfaceTypeConfig<
  Source,
  Fields extends Record<
    string,
    GInterfaceField<any, GOutputType<Context>, Context>
  >,
  Interfaces extends readonly GInterfaceType<Source, any, Context>[],
  Context,
> = Flatten<
  {
    fields: Fields | (() => Fields);
    interfaces?: [...Interfaces];
  } & Omit<GraphQLInterfaceTypeConfig<Source, Context>, "interfaces" | "fields">
>;

/**
 * A GraphQL argument. These should be created with {@link g.arg}
 *
 * Args can can be used as arguments on output fields:
 *
 * ```ts
 * g.field({
 *   type: g.String,
 *   args: {
 *     something: g.arg({ type: g.String }),
 *   },
 *   resolve(source, { something }) {
 *     return something || somethingElse;
 *   },
 * });
 * // ==
 * graphql`fieldName(something: String): String`;
 * ```
 *
 * Or as fields on input objects:
 *
 * ```ts
 * g.inputObject({
 *   name: "Something",
 *   fields: {
 *     something: g.arg({ type: g.String }),
 *   },
 * });
 * // ==
 * graphql`
 *   input Something {
 *     something: String
 *   }
 * `;
 * ```
 *
 * When the type of an arg is {@link GNonNull non-null}, the value will always
 * exist.
 *
 * ```ts
 * g.field({
 *   type: g.String,
 *   args: {
 *     something: g.arg({ type: g.nonNull(g.String) }),
 *   },
 *   resolve(source, { something }) {
 *     // `something` will always be a string
 *     return something;
 *   },
 * });
 * // ==
 * graphql`fieldName(something: String!): String`;
 * ```
 */
export type GArg<
  Type extends GInputType,
  HasDefaultValue extends boolean = boolean,
> = {
  type: Type;
  defaultValue: {
    true: {} | null;
    false: undefined;
  }[`${HasDefaultValue}`];
  description?: Maybe<string>;
  deprecationReason?: Maybe<string>;
  extensions?: Maybe<GraphQLInputFieldExtensions & GraphQLArgumentExtensions>;
  astNode?: Maybe<InputValueDefinitionNode>;
};

export type GInputObjectTypeConfig<
  Fields extends {
    [key: string]: IsOneOf extends true
      ? GArg<GNullableInputType, false>
      : GArg<GInputType>;
  },
  IsOneOf extends boolean = false,
> = Flatten<
  Omit<GraphQLInputObjectTypeConfig, "fields"> & {
    fields: Fields | (() => Fields);
    isOneOf?: IsOneOf;
  }
> &
  (true extends IsOneOf ? { isOneOf: unknown } : unknown);

/**
 * A GraphQL input object type. This should generally be constructed with
 * {@link g.inputObject}.
 *
 * Unlike some other constructors in this module, this constructor functions
 * exactly the same as it's counterpart `g.inputObject` so it is safe to use
 * directly if desired.
 */
export class GInputObjectType<
  Fields extends {
    [key: string]: IsOneOf extends true
      ? GArg<GNullableInputType, false>
      : GArg<GInputType>;
  },
  IsOneOf extends boolean = false,
> extends GraphQLInputObjectType {
  isOneOf: IsOneOf;
  constructor(config: Readonly<GInputObjectTypeConfig<Fields, IsOneOf>>);
  getFields(): {
    [K in keyof Fields]: GraphQLInputField & {
      type: Fields[K]["type"];
      defaultValue: Fields[K]["defaultValue"];
    };
  };
}

export type GEnumValueConfig<Value> = GraphQLEnumValueConfig & {
  value: Value;
};

export type GEnumTypeConfig<Values extends { [key: string]: unknown }> =
  Flatten<
    {
      values: {
        [Name in keyof Values]: GEnumValueConfig<Values[Name]>;
      };
    } & Omit<GraphQLEnumTypeConfig, "values">
  >;

/**
 * A GraphQL enum type. This should generally be constructed with {@link g.enum}.
 *
 * Unlike some other constructors in this module, this constructor functions
 * exactly the same as it's counterpart `g.enum` so it is safe to use directly
 * if desired.
 */
export class GEnumType<
  const Values extends { [key: string]: unknown },
> extends GraphQLEnumType {
  constructor(config: Readonly<GEnumTypeConfig<Values>>);
  toConfig(): Omit<ReturnType<GraphQLEnumType["toConfig"]>, "values"> & {
    values: {
      [Name in keyof Values]: Partial<GEnumValueConfig<Values[Name]>>;
    };
  };
}

/**
 * A GraphQL enum type. This should generally be constructed with
 * {@link g.scalar}.
 *
 * Unlike some other constructors in this module, this constructor functions
 * exactly the same as it's counterpart `g.scalar` so it is safe to use directly
 * if desired.
 *
 * Also unlike some other types in this module, this type is exactly equivalent
 * to the original {@link GraphQLScalarType `GraphQLScalarType`} type from the
 * `graphql` package.
 */
export class GScalarType<
  Internal = unknown,
  External = Internal,
> extends GraphQLScalarType<Internal, External> {}

type Flatten<T> = {
  [K in keyof T]: T[K];
} & {};

/**
 * A GraphQL non-null type. This should generally be constructed with
 * {@link g.nonNull}.
 *
 * Unlike some other constructors in this module, this constructor functions
 * exactly the same as it's counterpart `g.nonNull` so it is safe to use
 * directly if desired.
 *
 * Also unlike the named types in this module, the original
 * {@link GraphQLNonNull `GraphQLNonNull`} type from the `graphql` package cannot
 * be assigned to a variable of type `GNonNull`. Though `GNonNull` _is_
 * assignable to `GraphQLNonNull`.
 *
 * For example, the following code will not compile:
 *
 * ```ts
 * const nonNull: GNonNull<GScalarType<string>> = new GraphQLNonNull(
 *   GraphQLString
 * );
 * ```
 *
 * But the following code will compile:
 *
 * ```ts
 * const nonNull: GraphQLNonNull<GraphQLScalarType<string>> = new GNonNull(
 *   GraphQLString
 * );
 * ```
 *
 * This is due to the lack of a discriminating property between the
 * `GraphQLNonNull` and `GraphQLList` types.
 */
export class GNonNull<
  Of extends GNullableType<any>,
> extends GraphQLNonNull<Of> {
  get [Symbol.toStringTag](): "GraphQLNonNull";
}

/**
 * A GraphQL list type. This should generally be constructed with {@link g.list}.
 *
 * Unlike some other constructors in this module, this constructor functions
 * exactly the same as it's counterpart `g.list` so it is safe to use directly
 * if desired.
 *
 * Also unlike the named types in this module, the original
 * {@link GraphQLList `GraphQLList`} type from the `graphql` package cannot be
 * assigned to a variable of type `GList`. Though `GList` _is_ assignable to
 * `GraphQLList`.
 *
 * For example, the following code will not compile:
 *
 * ```ts
 * const list: GList<GScalarType<string>> = new GraphQLList(GraphQLString);
 * ```
 *
 * But the following code will compile:
 *
 * ```ts
 * const list: GraphQLList<GraphQLScalarType<string>> = new GList(
 *   GraphQLString
 * );
 * ```
 *
 * This is due to the lack of a discriminating property between the
 * `GraphQLNonNull` and `GraphQLList` types.
 */
export class GList<Of extends GType<any>> extends GraphQLList<Of> {
  get [Symbol.toStringTag](): "GraphQLList";
}

export {};