bingex

defmodule Bingex.Swap.Marshal do
  @moduledoc false

  alias Bingex.Model.Order
  alias Bingex.{Convertors, Helpers}

  @spec serialize_orders([Order.t()]) :: binary()
  def serialize_orders(orders) when is_list(orders) do
    Enum.map(orders, fn order ->
      order
      |> transform_order()
      |> Map.new()
      |> Helpers.serialize()
    end)
    |> Helpers.serialize()
  end

  @spec serialize_order(Order.t()) :: binary()
  def serialize_order(%Order{} = order) do
    order
    |> transform_order()
    |> Helpers.serialize()
  end

  @spec transform_order(Order.t()) :: [{term(), term()}]
  def transform_order(%Order{} = order) do
    order
    |> Map.from_struct()
    |> Helpers.reject_nils()
    |> adapt_order_values()
  end

  defp adapt_order_values(kv_list) do
    Enum.map(kv_list, fn
      {:side, v} ->
        {"side", Convertors.encode_order_side(v)}

      {:type, v} ->
        {"type", Convertors.encode_order_type(v)}

      {:position_side, v} ->
        {"positionSide", Convertors.encode_position_side(v)}

      {:working_type, v} ->
        {"workingType", Convertors.encode_working_type(v)}

      {:client_order_id, v} ->
        {"clientOrderID", v}

      {:order_id, v} ->
        {"orderId", v}

      {:stop_price, v} ->
        {"stopPrice", v}

      {k, v} ->
        {to_string(k), v}
    end)
  end
end