bingex

defmodule Bingex.Swap.Model.PositionInfo do
  @moduledoc """
  Represents individual position information.
  """
  import Bingex.{Helpers, Convertors}

  alias Bingex.Types

  defstruct [
    :id,
    :symbol,
    :side,
    :isolated?,
    :leverage,
    :create_time,
    :update_time,
    :average_price,
    :mark_price,
    :liquidation_price,
    :quantity,
    :available_quantity,
    :margin,
    :initial_margin,
    :value,
    :pnl_ratio,
    :realised_profit,
    :unrealised_profit,
    :risk_rate,
    :only_one_position?
  ]

  @type t() :: %__MODULE__{
          id: nil | binary(),
          symbol: nil | binary(),
          side: nil | Types.position_side(),
          isolated?: nil | boolean(),
          leverage: nil | pos_integer(),
          create_time: nil | non_neg_integer(),
          update_time: nil | non_neg_integer(),
          average_price: nil | float(),
          mark_price: nil | float(),
          liquidation_price: nil | float(),
          quantity: nil | float(),
          available_quantity: nil | float(),
          margin: nil | float(),
          initial_margin: nil | float(),
          value: nil | float(),
          pnl_ratio: nil | float(),
          realised_profit: nil | float(),
          unrealised_profit: nil | float(),
          risk_rate: nil | float(),
          only_one_position?: nil | boolean()
        }

  @spec decode(map()) :: {:ok, t()} | :error
  def decode(%{} = data) do
    {:ok,
     %__MODULE__{
       id: get_and_transform(data, "positionId", &to_non_empty_binary/1),
       side: get_and_transform(data, "positionSide", &decode_position_side/1),
       symbol: get_and_transform(data, "symbol", &to_non_empty_binary/1),
       quantity: get_and_transform(data, "positionAmt", &to_float/1),
       available_quantity: get_and_transform(data, "availableAmt", &to_float/1),
       margin: get_and_transform(data, "margin", &to_float/1),
       value: get_and_transform(data, "positionValue", &to_float/1),
       isolated?: get_and_transform(data, "isolated", &to_boolean/1),
       leverage: get_and_transform(data, "leverage", &to_integer/1),
       create_time: get_and_transform(data, "createTime", &to_integer/1),
       update_time: get_and_transform(data, "updateTime", &to_integer/1),
       average_price: get_and_transform(data, "avgPrice", &to_float/1),
       mark_price: get_and_transform(data, "markPrice", &to_float/1),
       liquidation_price: get_and_transform(data, "liquidationPrice", &to_float/1),
       initial_margin: get_and_transform(data, "initialMargin", &to_float/1),
       pnl_ratio: get_and_transform(data, "pnlRatio", &to_float/1),
       realised_profit: get_and_transform(data, "realisedProfit", &to_float/1),
       unrealised_profit: get_and_transform(data, "unrealizedProfit", &to_float/1),
       risk_rate: get_and_transform(data, "riskRate", &to_float/1),
       only_one_position?: get_and_transform(data, "onlyOnePosition", &to_boolean/1)
     }}
  end

  def decode(_), do: :error
end