import { getHttpStatusText } from '@wener/utils';

export function resolveErrorMessage(error: Error | any) {
	if (!error) {
		return;
	}

	if (!(error instanceof Error)) {
		if (error && typeof error === 'object') {
			if ('message' in error) {
				return error.message;
			}
			if ('detail' in error) {
				return error.detail;
			}
		}
		return String(error);
	}

	try {
		if (isZodError(error)) {
			return error.issues.map((v) => `${v.path.join('.')}: ${v.message}`).join(';');
		}
		if (isTypeBoxError(error)) {
			const { path, type, message } = error.error;
			return `${path}: ${message} (${type})`;
		}
		if (URQLError.is(error)) {
			return error.response.errors.map((v: any) => v.message).join(';');
		}

		const buildGraphQLError = (errors: GraphQLError[] = []) => {
			return errors
				.map((v) => {
					return `${v.message}`;
				})
				.join(';');
		};

		const buildGraphQLResponseError = ({
			response,
		}: {
			response: {
				status: number;
				errors?: GraphQLError[];
			};
		}) => {
			let s = [''];
			let status = response.status;
			if (status !== 200) {
				s.push(`${status} ${getHttpStatusText(status)}`);
			}
			if (response.errors) {
				s.push(buildGraphQLError(response.errors));
			}
			return s.join(' ');
		};

		if (GraphQL.isClientError(error)) {
			return buildGraphQLResponseError(error);
		}

		if (typeof error === 'object' && 'message' in error) {
			return error.message;
		}
	} catch (e) {
		console.error('resolveErrorMessage', e);
	}
	return String(error);
}

namespace GraphQL {
	interface GraphQLResponse<T = unknown> {
		data?: T;
		errors?: GraphQLError[];
		extensions?: unknown;
		status: number;
		headers?: Headers;

		[key: string]: unknown;
	}

	interface GraphQLRequestContext<V extends {} = {}> {
		query: string | string[];
		variables?: V;
	}

	type ClientError = Error & {
		response: GraphQLResponse;
		request: GraphQLRequestContext;
	};

	export function isClientError(error: any): error is ClientError {
		// graphql-client _ClientError
		// https://github.com/graffle-js/graffle/blob/graphql-request/src/legacy/classes/ClientError.ts
		return (
			typeof error.response === 'object' &&
			typeof error.request === 'object' &&
			typeof error.response.status === 'number' &&
			typeof error.request.query === 'string' &&
			(error.response.errors === undefined || error.response.errors === null || Array.isArray(error.response.errors))
		);
	}
}

function isTypeBoxError(error: any): error is TransformDecodeCheckError {
	return error.error?.path && error.error.type && error.error.message && error instanceof Error;
}

interface TransformDecodeCheckError extends Error {
	error: {
		path: string;
		type: string;
		message: string;
	};
}

function isZodError(error: any): error is ZodError {
	return error instanceof Error && Array.isArray((error as any).issues);
}

interface ZodIssue {
	fatal?: boolean;
	code: any;
	path: (string | number)[];
	message: string;
}

interface ZodError {
	issues: ZodIssue[];

	get errors(): ZodIssue[];

	get message(): string;

	get isEmpty(): boolean;
}

// https://commerce.nearform.com/open-source/urql/docs/basics/errors/
// https://github.com/urql-graphql/urql/blob/main/packages/core/src/utils/error.ts
// urql CombinedError
namespace URQLError {
	// import { GraphQLError } from '@0no-co/graphql.web';

	/** An abstracted `Error` that provides either a `networkError` or `graphQLErrors`.
	 *
	 * @remarks
	 * During a GraphQL request, either the request can fail entirely, causing a network error,
	 * or the GraphQL execution or fields can fail, which will cause an {@link ExecutionResult}
	 * to contain an array of GraphQL errors.
	 *
	 * The `CombinedError` abstracts and normalizes both failure cases. When {@link OperationResult.error}
	 * is set to this error, the `CombinedError` abstracts all errors, making it easier to handle only
	 * a subset of error cases.
	 *
	 * @see {@link https://urql.dev/goto/docs/basics/errors} for more information on handling
	 * GraphQL errors and the `CombinedError`.
	 */
	export interface CombinedError extends Error {
		name: string;
		message: string;

		/** A list of GraphQL errors rehydrated from a {@link ExecutionResult}.
		 *
		 * @remarks
		 * If an {@link ExecutionResult} received from the API contains a list of errors,
		 * the `CombinedError` will rehydrate them, normalize them to
		 * {@link GraphQLError | GraphQLErrors} and list them here.
		 * An empty list indicates that no GraphQL error has been sent by the API.
		 */
		graphQLErrors: GraphQLError[];

		/** Set to an error, if a GraphQL request has failed outright.
		 *
		 * @remarks
		 * A GraphQL over HTTP request may fail and not reach the API. Any error that
		 * prevents a GraphQl request outright, will be considered a “network error” and
		 * set here.
		 */
		networkError?: Error;

		/** Set to the {@link Response} object a fetch exchange received.
		 *
		 * @remarks
		 * If a built-in fetch {@link Exchange} is used in `urql`, this may
		 * be set to the {@link Response} object of the Fetch API response.
		 * However, since `urql` doesn’t assume that all users will use HTTP
		 * as the only or exclusive transport for GraphQL this property is
		 * neither typed nor guaranteed and may be re-used for other purposes
		 * by non-fetch exchanges.
		 *
		 * Hint: It can be useful to use `response.status` here, however, if
		 * you plan on relying on this being a {@link Response} in your app,
		 * which it is by default, then make sure you add some extra checks
		 * before blindly assuming so!
		 */
		response?: any;
	}

	export function is(error: any): error is CombinedError {
		return Array.isArray(error?.graphQLErrors) && error.name === 'CombinedError' && error instanceof Error;
	}
}

interface CombinedError extends Error {
	name: string;
	message: string;
	graphQLErrors: GraphQLError[];
	networkError?: Error;
	response?: any;
}

// import type { GraphQLError } from 'graphql'

interface GraphQLError extends Error {
	readonly locations: ReadonlyArray<any> | undefined;
	readonly path: ReadonlyArray<string | number> | undefined;
	readonly nodes: ReadonlyArray<any> | undefined;
	readonly source:
		| {
				body: string;
				name: string;
				locationOffset: {
					line: number;
					column: number;
				};
		  }
		| undefined;
	readonly positions: ReadonlyArray<number> | undefined;
	readonly originalError: Error | undefined;
	readonly extensions: Record<string, any>;
}