bingex

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

  alias Bingex.{Types, HTTP, API}

  alias Bingex.User.Data.{
    GenerateListenKey,
    GetReferrals,
    GetReferral,
    GetUID
  }

  @auth_path "/openApi/user/auth"
  @agent_v1_path "/openApi/agent/v1"
  @agent_account_v1_path @agent_v1_path <> "/account"
  @account_v1_path "/openApi/account/v1"

  # Auth
  @generate_listen_key_path @auth_path <> "/userDataStream"
  @extend_listen_key_path @auth_path <> "/userDataStream"

  # Account
  @get_uid_path @account_v1_path <> "/uid"

  # Agent
  @get_referrals_path @agent_account_v1_path <> "/inviteAccountList"
  @get_referral_path @agent_account_v1_path <> "/inviteRelationCheck"

  @doc """
  Query Account UID.

  https://bingx-api.github.io/docs-v3/#/en/Account%20and%20Wallet/Sub-account%20Management/%20Query%20Account%20UID
  """
  @spec get_uid(Types.api_key(), Types.secret_key()) ::
          Types.request_result(API.Reply.t(GetUID.t()))
  def get_uid(api_key, secret_key) when is_binary(api_key) and is_binary(secret_key) do
    request = get_uid_request(api_key, secret_key)

    with {:ok, reply, meta} <- request(request) do
      {:ok, GetUID.embed_in_reply(reply), meta}
    end
  end

  @doc """
  Generate Listen Key (used for WebSocket connection). Listen key Valid for 1 hour.

  https://bingx-api.github.io/docs/#/en-us/common/authentication-interface.html#generate%20Listen%20Key
  """
  @spec generate_listen_key(Types.api_key()) ::
          Types.request_result(API.Reply.t(GenerateListenKey.t()))
  def generate_listen_key(api_key) when is_binary(api_key) do
    request = generate_listen_key_request(api_key)

    with {:ok, reply, meta} <- request(request) do
      {:ok, GenerateListenKey.embed_in_reply(reply), meta}
    end
  end

  @doc """
  The validity period is extended to 1 hour after this call, and it is recommended to send a ping every 30 minutes.

  https://bingx-api.github.io/docs/#/en-us/common/authentication-interface.html#extend%20Listen%20Key%20Validity%20period
  """
  @spec extend_listen_key(Types.listen_key(), Types.api_key()) ::
          Types.request_result()
  def extend_listen_key(listen_key, api_key)
      when is_binary(listen_key) and is_binary(api_key) do
    extend_listen_key_request(listen_key, api_key)
    |> request()
  end

  @doc """
  Query whether the corresponding UID is an invited user under his or her name.

  https://bingx-api.github.io/docs/#/en-us/agent/agent-interface.html#Query%20agent%20user%20information
  """
  @spec get_referral(
          Types.user_id(),
          Types.api_key(),
          Types.secret_key()
        ) :: Types.request_result(API.Reply.t(GetReferral.t()))
  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, reply, meta} <- request(request) do
      {:ok, GetReferral.embed_in_reply(reply), meta}
    end
  end

  @doc """
  Query basic information of invited subordinate users.

  https://bingx-api.github.io/docs/#/en-us/agent/agent-interface.html#Query%20Invited%20Users
  """
  @spec get_referrals(
          page_index :: pos_integer(),
          page_size :: pos_integer(),
          Types.api_key(),
          Types.secret_key(),
          opts :: [
            start_time: pos_integer(),
            end_time: pos_integer()
          ]
        ) :: Types.request_result(API.Reply.t(GetReferrals.t()))
  def get_referrals(page_index, page_size, api_key, secret_key, opts \\ [])
      when is_integer(page_index) and
             is_integer(page_size) and
             is_binary(api_key) and
             is_binary(secret_key) do
    request =
      get_referrals_request(
        page_index,
        page_size,
        api_key,
        secret_key,
        opts
      )

    with {:ok, reply, meta} <- request(request) do
      {:ok, GetReferrals.embed_in_reply(reply), meta}
    end
  end

  #
  # Helpers
  #

  @spec request(HTTP.Request.t()) :: Types.request_result()
  defp request(%HTTP.Request{} = request) do
    metadata = %{request: request}

    case HTTP.request(request) do
      {:ok, response} ->
        metadata = Map.put(metadata, :response, response)

        case API.process_response(response) do
          {:ok, reply} -> {:ok, reply, metadata}
          {:error, error} -> {:error, error, metadata}
        end

      {:error, error} ->
        {:error, error, metadata}
    end
  end

  defp get_uid_request(api_key, secret_key) do
    HTTP.create_signed_request(
      :get,
      @get_uid_path,
      [],
      api_key,
      secret_key
    )
  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,
         api_key,
         secret_key,
         opts
       ) do
    start_time = Keyword.get(opts, :start_time)
    end_time = Keyword.get(opts, :end_time)

    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