// Copyright (c) Mysten Labs, Inc.
// Modifications Copyright (c) 2024 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
import type { TadaDocumentNode } from 'gql.tada';
import type { DocumentNode } from 'graphql';
import { print } from 'graphql';

export type GraphQLDocument<
    Result = Record<string, unknown>,
    Variables = Record<string, unknown>,
> =
    | string
    | DocumentNode
    | TypedDocumentNode<Result, Variables>
    | TadaDocumentNode<Result, Variables>;

export type GraphQLQueryOptions<
    Result = Record<string, unknown>,
    Variables = Record<string, unknown>,
> = {
    query: GraphQLDocument<Result, Variables>;
    operationName?: string;
    extensions?: Record<string, unknown>;
} & (Variables extends { [key: string]: never }
    ? { variables?: Variables }
    : {
          variables: Variables;
      });

export type GraphQLQueryResult<Result = Record<string, unknown>> = {
    data?: Result;
    errors?: GraphQLResponseErrors;
    extensions?: Record<string, unknown>;
};

export type GraphQLResponseErrors = Array<{
    message: string;
    locations?: { line: number; column: number }[];
    path?: (string | number)[];
}>;

export interface IotaGraphQLClientOptions<Queries extends Record<string, GraphQLDocument>> {
    url: string;
    fetch?: typeof fetch;
    headers?: Record<string, string>;
    queries?: Queries;
}

export class IotaGraphQLRequestError extends Error {}

// eslint-disable-next-line @typescript-eslint/ban-types
export class IotaGraphQLClient<Queries extends Record<string, GraphQLDocument> = {}> {
    #url: string;
    #queries: Queries;
    #headers: Record<string, string>;
    #fetch: typeof fetch;

    constructor({
        url,
        fetch: fetchFn = fetch,
        headers = {},
        queries = {} as Queries,
    }: IotaGraphQLClientOptions<Queries>) {
        this.#url = url;
        this.#queries = queries;
        this.#headers = headers;
        this.#fetch = (...args) => fetchFn(...args);
    }

    async query<Result = Record<string, unknown>, Variables = Record<string, unknown>>(
        options: GraphQLQueryOptions<Result, Variables>,
    ): Promise<GraphQLQueryResult<Result>> {
        const res = await this.#fetch(this.#url, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                ...this.#headers,
            },
            body: JSON.stringify({
                query:
                    typeof options.query === 'string'
                        ? String(options.query)
                        : print(options.query),
                variables: options.variables,
                extensions: options.extensions,
                operationName: options.operationName,
            }),
        });

        if (!res.ok) {
            throw new IotaGraphQLRequestError(
                `GraphQL request failed: ${res.statusText} (${res.status})`,
            );
        }

        return await res.json();
    }

    async execute<
        const Query extends Extract<keyof Queries, string>,
        Result = Queries[Query] extends GraphQLDocument<infer R, unknown>
            ? R
            : Record<string, unknown>,
        Variables = Queries[Query] extends GraphQLDocument<unknown, infer V>
            ? V
            : Record<string, unknown>,
    >(
        query: Query,
        options: Omit<GraphQLQueryOptions<Result, Variables>, 'query'>,
    ): Promise<GraphQLQueryResult<Result>> {
        return this.query({
            ...(options as { variables: Record<string, unknown> }),
            query: this.#queries[query]!,
        }) as Promise<GraphQLQueryResult<Result>>;
    }
}