bingex

defmodule Bingex.User do
  @moduledoc """
  Provides an interface to interact with the BingX User API.

  This module enables users to manage authentication tokens, retrieve referral details, and handle account-related requests. It facilitates secure API interactions by generating and extending listen keys for user data streams and retrieving referral information.

  Key features:
    - Generate and extend listen keys for user data streams
    - Retrieve referral details for a specific user
    - Fetch lists of referred users
    - Secure request signing for authenticated API calls

  All requests requiring authentication will be signed using an API key and secret key.

  """

  alias Bingex.Types
  alias Bingex.HTTP
  alias Bingex.API

  alias Bingex.User.{
    GenerateListenKeyData,
    GetReferralsData,
    GetReferralData
  }

  @auth_scope "/openApi/user/auth"
  @generate_listen_key_path @auth_scope <> "/userDataStream"
  @extend_listen_key_path @auth_scope <> "/userDataStream"

  @account_scope "/openApi/agent/v1/account"
  @get_referrals_path @account_scope <> "/inviteAccountList"
  @get_referral_path @account_scope <> "/inviteRelationCheck"

  @spec generate_listen_key(api_key :: binary()) ::
          {:ok, API.Reply.t(GenerateListenKeyData.t()), Types.request_metadata()}
          | {:error, API.Error.t(), Types.request_metadata()}
          | {:error, HTTP.Error.t(), Types.failed_request_metadata()}
  def generate_listen_key(api_key) when is_binary(api_key) do
    request = generate_listen_key_request(api_key)

    with(
      {:ok, response} <- request(request),
      {:ok, reply} <- process_response(response, request)
    ) do
      {:ok, GenerateListenKeyData.embed_in_reply(reply), {request, response}}
    end
  end

  @spec extend_listen_key(listen_key :: binary(), api_key :: binary()) ::
          {:ok, API.Reply.t(), Types.request_metadata()}
          | {:error, API.Error.t(), Types.request_metadata()}
          | {:error, HTTP.Error.t(), Types.failed_request_metadata()}
  def extend_listen_key(listen_key, api_key)
      when is_binary(listen_key) and is_binary(api_key) do
    request = extend_listen_key_request(listen_key, api_key)

    with(
      {:ok, response} <- request(request),
      {:ok, reply} <- process_response(response, request)
    ) do
      {:ok, reply, {request, response}}
    end
  end

  @spec get_referral(
          user_id :: binary(),
          api_key :: binary(),
          secret_key :: binary()
        ) ::
          {:ok, API.Reply.t(GetReferralData.t()), Types.request_metadata()}
          | {:error, API.Error.t(), Types.request_metadata()}
          | {:error, HTTP.Error.t(), Types.failed_request_metadata()}
  def get_referral(
        user_id,
        api_key,
        secret_key
      )
      when (is_binary(user_id) or is_integer(user_id)) and
             is_binary(api_key) and
             is_binary(secret_key) do
    request = get_referral_request(user_id, api_key, secret_key)

    with(
      {:ok, response} <- request(request),
      {:ok, reply} <- process_response(response, request)
    ) do
      {:ok, GetReferralData.embed_in_reply(reply), {request, response}}
    end
  end

  @spec get_referrals(
          page_index :: non_neg_integer(),
          page_size :: non_neg_integer(),
          start_time :: nil | non_neg_integer(),
          end_time :: nil | non_neg_integer(),
          api_key :: binary(),
          secret_key :: binary()
        ) ::
          {:ok, API.Reply.t(GetReferralsData.t()), Types.request_metadata()}
          | {:error, API.Error.t(), Types.request_metadata()}
          | {:error, HTTP.Error.t(), Types.failed_request_metadata()}
  def get_referrals(
        page_index \\ 0,
        page_size \\ 200,
        start_time \\ nil,
        end_time \\ nil,
        api_key,
        secret_key
      )
      when is_integer(page_index) and
             is_integer(page_size) and
             (is_integer(start_time) or start_time == nil) and
             (is_integer(end_time) or end_time == nil) and
             is_binary(api_key) and
             is_binary(secret_key) do
    request =
      get_referrals_request(
        page_index,
        page_size,
        start_time,
        end_time,
        api_key,
        secret_key
      )

    with(
      {:ok, response} <- request(request),
      {:ok, reply} <- process_response(response, request)
    ) do
      {:ok, GetReferralsData.embed_in_reply(reply), {request, response}}
    end
  end

  #
  # Helpers
  #

  defp process_response(%HTTP.Response{} = response, request) do
    with {:error, error} <- API.process_response(response) do
      {:error, error, {request, response}}
    end
  end

  defp request(%HTTP.Request{} = request) do
    with {:error, error} <- HTTP.request(request) do
      {:error, error, request}
    end
  end

  defp get_referral_request(user_id, api_key, secret_key) do
    params = [{"uid", user_id}]

    HTTP.create_signed_request(
      :get,
      @get_referral_path,
      params,
      api_key,
      secret_key
    )
  end

  defp get_referrals_request(
         page_index,
         page_size,
         start_time,
         end_time,
         api_key,
         secret_key
       ) do
    params = [
      {"pageIndex", page_index},
      {"pageSize", page_size},
      {"startTime", start_time},
      {"endTime", end_time}
    ]

    HTTP.create_signed_request(
      :get,
      @get_referrals_path,
      params,
      api_key,
      secret_key
    )
  end

  defp generate_listen_key_request(api_key) do
    HTTP.create_authed_request(:post, @generate_listen_key_path, api_key)
  end

  defp extend_listen_key_request(listen_key, api_key) do
    params = [{"listenKey", listen_key}]

    HTTP.create_authed_request(
      :put,
      @extend_listen_key_path,
      params,
      api_key
    )
  end
end