/**
 * Do not edit this file it is auto-generated by io-utils / gen-api-models.
 * See https://github.com/pagopa/io-utils
 */
/* eslint-disable  */

import { withoutUndefinedValues } from "@pagopa/ts-commons/lib/types";
import {
  RequestParams,
  TypeofApiCall,
  TypeofApiParams,
  createFetchRequestForApi,
  ReplaceRequestParams
} from "@pagopa/ts-commons/lib/requests";
import { identity } from "fp-ts/lib/function";

import { NotifyT, notifyDefaultDecoder } from "./requestTypes";

// This is a placeholder for undefined when dealing with object keys
// Typescript doesn't perform well when narrowing a union type which includes string and undefined
// (example: "foo" | "bar" | undefined)
// We use this as a placeholder for type parameters indicating "no key"
type __UNDEFINED_KEY = "_____";

export type ApiOperation = TypeofApiCall<NotifyT>;

export type ParamKeys = keyof TypeofApiParams<NotifyT>;

/**
 * Defines an adapter for TypeofApiCall which omit one or more parameters in the signature
 * @param ApiT the type which defines the operation to expose
 * @param K the parameter to omit. undefined means no parameters will be omitted
 */
export type OmitApiCallParams<
  ApiT,
  K extends ParamKeys | __UNDEFINED_KEY = __UNDEFINED_KEY
> = (
  op: TypeofApiCall<ApiT>
) => K extends __UNDEFINED_KEY
  ? TypeofApiCall<ApiT>
  : TypeofApiCall<ReplaceRequestParams<ApiT, Omit<RequestParams<ApiT>, K>>>;

/**
 * Defines an adapter for TypeofApiCall which omit one or more parameters in the signature
 * @param ApiT the type which defines the operation to expose
 * @param K the parameter to omit. undefined means no parameters will be omitted
 */
export type WithDefaultsT<
  K extends ParamKeys | __UNDEFINED_KEY = __UNDEFINED_KEY
> = OmitApiCallParams<NotifyT, K>;

/**
 * Defines a collection of api operations
 * @param K name of the parameters that the Clients masks from the operations
 */
export type Client<
  K extends ParamKeys | __UNDEFINED_KEY = __UNDEFINED_KEY
> = K extends __UNDEFINED_KEY
  ? {
      readonly notify: TypeofApiCall<NotifyT>;
    }
  : {
      readonly notify: TypeofApiCall<
        ReplaceRequestParams<NotifyT, Omit<RequestParams<NotifyT>, K>>
      >;
    };

/**
 * Create an instance of a client
 * @param params hash map of parameters thata define the client:
 *  - baseUrl: the base url for every api call (required)
 *  - fetchApi: an implementation of the fetch() web API, depending on the platform (required)
 *  - basePath: optional path to be appended to the baseUrl
 *  - withDefaults: optional adapter to be applied to every operation, to omit some paramenters
 * @returns a collection of api operations
 */
export function createClient<K extends ParamKeys>(params: {
  baseUrl: string;
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  fetchApi: typeof fetch;
  withDefaults: WithDefaultsT<K>;
  basePath?: string;
}): Client<K>;
export function createClient(params: {
  baseUrl: string;
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  fetchApi: typeof fetch;
  withDefaults?: undefined;
  basePath?: string;
}): Client;
export function createClient<K extends ParamKeys>({
  baseUrl,
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  fetchApi,
  withDefaults,
  basePath = "/api/v1"
}: {
  baseUrl: string;
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  fetchApi: typeof fetch;
  withDefaults?: WithDefaultsT<K>;
  basePath?: string;
}) {
  const options = {
    baseUrl,
    fetchApi
  };

  const notifyT: ReplaceRequestParams<NotifyT, RequestParams<NotifyT>> = {
    method: "post",

    headers: () => ({
      "Content-Type": "application/json"
    }),
    response_decoder: notifyDefaultDecoder(),
    url: ({}) => `${basePath}/notify`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => withoutUndefinedValues({})
  };
  const notify: TypeofApiCall<NotifyT> = createFetchRequestForApi(
    notifyT,
    options
  );

  return {
    notify: (withDefaults || identity)(notify)
  };
}