/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import { ApexascendCore } from "../core.js";
import { encodeSimple } from "../lib/encodings.js";
import * as M from "../lib/matchers.js";
import { compactMap } from "../lib/primitives.js";
import { safeParse } from "../lib/schemas.js";
import { RequestOptions } from "../lib/sdks.js";
import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
import { pathToFunc } from "../lib/url.js";
import { ApexascendError } from "../models/errors/apexascenderror.js";
import {
  ConnectionError,
  InvalidRequestError,
  RequestAbortedError,
  RequestTimeoutError,
  UnexpectedClientError,
} from "../models/errors/httpclienterrors.js";
import * as errors from "../models/errors/index.js";
import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
import * as operations from "../models/operations/index.js";
import { APICall, APIPromise } from "../types/async.js";
import { Result } from "../types/fp.js";

/**
 * Get Watchlist Item
 *
 * @remarks
 * Gets the details of the watchlist profile by the watchlist_id and watchlist_item_id, returned as part of an investigation's watchlist screening process. The response returns the details of the specific watchlist profile that matched the screened identity. Clients can refer to these properties when adjudicating potential watchlist matches. Watchlist_id must equal DOWJONES or DNDB
 */
export function investigationsGetWatchlistItem(
  client: ApexascendCore,
  watchlistId: string,
  itemId: string,
  options?: RequestOptions,
): APIPromise<
  Result<
    operations.WatchlistServiceGetWatchlistItemResponse,
    | errors.Status
    | ApexascendError
    | ResponseValidationError
    | ConnectionError
    | RequestAbortedError
    | RequestTimeoutError
    | InvalidRequestError
    | UnexpectedClientError
    | SDKValidationError
  >
> {
  return new APIPromise($do(
    client,
    watchlistId,
    itemId,
    options,
  ));
}

async function $do(
  client: ApexascendCore,
  watchlistId: string,
  itemId: string,
  options?: RequestOptions,
): Promise<
  [
    Result<
      operations.WatchlistServiceGetWatchlistItemResponse,
      | errors.Status
      | ApexascendError
      | ResponseValidationError
      | ConnectionError
      | RequestAbortedError
      | RequestTimeoutError
      | InvalidRequestError
      | UnexpectedClientError
      | SDKValidationError
    >,
    APICall,
  ]
> {
  const input: operations.WatchlistServiceGetWatchlistItemRequest = {
    watchlistId: watchlistId,
    itemId: itemId,
  };

  const parsed = safeParse(
    input,
    (value) =>
      operations.WatchlistServiceGetWatchlistItemRequest$outboundSchema.parse(
        value,
      ),
    "Input validation failed",
  );
  if (!parsed.ok) {
    return [parsed, { status: "invalid" }];
  }
  const payload = parsed.value;
  const body = null;

  const pathParams = {
    item_id: encodeSimple("item_id", payload.item_id, {
      explode: false,
      charEncoding: "percent",
    }),
    watchlist_id: encodeSimple("watchlist_id", payload.watchlist_id, {
      explode: false,
      charEncoding: "percent",
    }),
  };

  const path = pathToFunc(
    "/investigations/v1/watchlists/{watchlist_id}/items/{item_id}",
  )(pathParams);

  const headers = new Headers(compactMap({
    Accept: "application/json",
  }));

  const securityInput = await extractSecurity(client._options.security);
  const requestSecurity = resolveGlobalSecurity(securityInput);

  const context = {
    options: client._options,
    baseURL: options?.serverURL ?? client._baseURL ?? "",
    operationID: "WatchlistService_GetWatchlistItem",
    oAuth2Scopes: [],

    resolvedSecurity: requestSecurity,

    securitySource: client._options.security,
    retryConfig: options?.retries
      || client._options.retryConfig
      || {
        strategy: "backoff",
        backoff: {
          initialInterval: 500,
          maxInterval: 5000,
          exponent: 1.5,
          maxElapsedTime: 15000,
        },
        retryConnectionErrors: true,
      }
      || { strategy: "none" },
    retryCodes: options?.retryCodes || ["4XX", "5XX"],
  };

  const requestRes = client._createRequest(context, {
    security: requestSecurity,
    method: "GET",
    baseURL: options?.serverURL,
    path: path,
    headers: headers,
    body: body,
    userAgent: client._options.userAgent,
    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
  }, options);
  if (!requestRes.ok) {
    return [requestRes, { status: "invalid" }];
  }
  const req = requestRes.value;

  const doResult = await client._do(req, {
    context,
    errorCodes: ["400", "403", "404", "4XX", "500", "503", "5XX"],
    retryConfig: context.retryConfig,
    retryCodes: context.retryCodes,
  });
  if (!doResult.ok) {
    return [doResult, { status: "request-error", request: req }];
  }
  const response = doResult.value;

  const responseFields = {
    HttpMeta: { Response: response, Request: req },
  };

  const [result] = await M.match<
    operations.WatchlistServiceGetWatchlistItemResponse,
    | errors.Status
    | ApexascendError
    | ResponseValidationError
    | ConnectionError
    | RequestAbortedError
    | RequestTimeoutError
    | InvalidRequestError
    | UnexpectedClientError
    | SDKValidationError
  >(
    M.json(
      200,
      operations.WatchlistServiceGetWatchlistItemResponse$inboundSchema,
      { key: "WatchlistItem" },
    ),
    M.jsonErr([400, 403, 404], errors.Status$inboundSchema),
    M.jsonErr([500, 503], errors.Status$inboundSchema),
    M.fail("4XX"),
    M.fail("5XX"),
    M.json(
      "default",
      operations.WatchlistServiceGetWatchlistItemResponse$inboundSchema,
      { key: "Status" },
    ),
  )(response, req, { extraFields: responseFields });
  if (!result.ok) {
    return [result, { status: "complete", request: req, response }];
  }

  return [result, { status: "complete", request: req, response }];
}