import { HttpError } from "@cognite/sdk-core";

/** @hidden */
export function rethrowAsHttpError(error: any): HttpError {
  const headers: any = {};
  if (error.headers) {
    headers["X-Request-Id"] = error.headers["X-Request-Id"];
  }

  if (error instanceof HttpError) {
    return new HttpError(error.status, error.data, headers);
  } else if (isFetchError(error)) {
    return new HttpError(404, error.message, headers);
  } else if (error instanceof TypeError) {
    return new HttpError(401, error, headers);
  } else {
    const errorMessage = error.data?.error?.message ?? error.data;
    return new HttpError(error.status, errorMessage, headers);
  }
}

// https://gist.github.com/yuya-takeyama/2a18d166b43101ca77a461fded8916c9
export type FetchError =
  | NetworkError
  | RequestError
  | ServerError
  | UnknownError;

export const isFetchError = (err: FetchError | any): err is FetchError => {
  return (
    isNetworkError(err) ||
    isRequestError(err) ||
    isServerError(err) ||
    isUnknownError(err)
  );
};

export interface NetworkError extends Error {
  isNetworkError: boolean;
}

export interface RequestError extends ErrorWithResponse {
  isRequestError: boolean;
}

export interface ServerError extends ErrorWithResponse {
  isServerError: boolean;
}

export interface UnknownError extends ErrorWithResponse {
  isUnknownError: boolean;
}

export interface ErrorWithResponse extends Error {
  response: ResponseWithParsedJson;
}

interface ResponseWithParsedJson extends Response {
  parsedJson?: any;
}

export const isNetworkError = (
  err: NetworkError | any
): err is NetworkError => {
  return !!(err instanceof Error && (err as NetworkError).isNetworkError);
};

export const isRequestError = (
  err: RequestError | any
): err is RequestError => {
  return !!(err instanceof Error && (err as RequestError).isRequestError);
};

export const isServerError = (err: ServerError | any): err is ServerError => {
  return !!(err instanceof Error && (err as ServerError).isServerError);
};

export const isUnknownError = (
  err: UnknownError | any
): err is UnknownError => {
  return !!(err instanceof Error && (err as UnknownError).isUnknownError);
};