bingex

defmodule Bingex.Convertors do
  @moduledoc false

  alias Bingex.{Helpers, Types}

  @spec encode_income_type(Types.income_type()) :: binary()
  def encode_income_type(:transfer), do: "TRANSFER"
  def encode_income_type(:realized_pnl), do: "REALIZED_PNL"
  def encode_income_type(:funding_fee), do: "FUNDING_FEE"
  def encode_income_type(:trading_fee), do: "TRADING_FEE"

  @spec decode_income_type(binary()) :: Types.income_type() | nil
  def decode_income_type(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "TRANSFER" -> :transfer
      "REALIZED_PNL" -> :realized_pnl
      "FUNDING_FEE" -> :funding_fee
      "TRADING_FEE" -> :trading_fee
      _ -> nil
    end
  end

  def decode_income_type(_), do: nil

  def decode_margin_mode(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "ISOLATED" -> :isolated
      "CROSSED" -> :crossed
      "CROSS" -> :crossed
      _ -> nil
    end
  end

  def decode_margin_mode(_), do: nil

  def encode_margin_mode(:crossed), do: "CROSSED"
  def encode_margin_mode(:isolated), do: "ISOLATED"
  def encode_margin_mode(_), do: nil

  def decode_order_type(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "MARKET" -> :market
      "TRIGGER_MARKET" -> :trigger_market
      "STOP" -> :stop_loss
      "LIMIT" -> :limit
      "TAKE_PROFIT" -> :take_profit
      "STOP_MARKET" -> :stop_loss_market
      "TAKE_PROFIT_MARKET" -> :take_profit_market
      _ -> nil
    end
  end

  def decode_order_type(_), do: nil

  def encode_order_type(:market), do: "MARKET"
  def encode_order_type(:trigger_market), do: "TRIGGER_MARKET"
  def encode_order_type(:stop_loss), do: "STOP"
  def encode_order_type(:take_profit), do: "TAKE_PROFIT"
  def encode_order_type(:limit), do: "LIMIT"
  def encode_order_type(:stop_loss_market), do: "STOP_MARKET"
  def encode_order_type(:take_profit_market), do: "TAKE_PROFIT_MARKET"

  def decode_order_execution_type(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "NEW" -> :placed
      "CANCELED" -> :canceled
      "CANCELLED" -> :canceled
      "CALCULATED" -> :calculated
      "EXPIRED" -> :expired
      "TRADE" -> :trade
      _ -> nil
    end
  end

  def decode_order_execution_type(_), do: nil

  def decode_order_status(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "NEW" -> :placed
      "TRIGGERED" -> :triggered
      "FILLED" -> :filled
      "PARTIALLY_FILLED" -> :partially_filled
      "CANCELED" -> :canceled
      "CANCELLED" -> :canceled
      "EXPIRED" -> :expired
      _ -> nil
    end
  end

  def decode_order_status(_), do: nil

  def decode_position_side(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "LONG" -> :long
      "SHORT" -> :short
      "BOTH" -> :both
      _ -> nil
    end
  end

  def decode_position_side(_), do: nil

  def encode_position_side(:long), do: "LONG"
  def encode_position_side(:short), do: "SHORT"
  def encode_position_side(:both), do: "BOTH"

  def decode_order_side(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "BUY" -> :buy
      "SELL" -> :sell
      _ -> nil
    end
  end

  def decode_order_side(_), do: nil

  def encode_order_side(:sell), do: "SELL"
  def encode_order_side(:buy), do: "BUY"

  def decode_working_type(x) when is_binary(x) do
    case Helpers.upcase(x) do
      "INDEX_PRICE" -> :index_price
      "MARK_PRICE" -> :mark_price
      "CONTRACT_PRICE" -> :contract_price
      _ -> nil
    end
  end

  def decode_working_type(_), do: nil

  def encode_working_type(:index_price), do: "INDEX_PRICE"
  def encode_working_type(:mark_price), do: "MARK_PRICE"
  def encode_working_type(:contract_price), do: "CONTRACT_PRICE"

  def to_list(x) when is_list(x), do: x
  def to_list(_), do: nil

  def to_float(x) when is_number(x), do: x + 0.0

  def to_float(x) when is_binary(x) do
    case Float.parse(x) do
      :error -> nil
      {x, _} -> x
    end
  end

  def to_float(_), do: nil

  def to_map(%{} = data), do: data
  def to_map(_data), do: nil

  def to_non_neg_integer(x) do
    value = to_integer(x)

    if value != nil and value >= 0 do
      value
    else
      nil
    end
  end

  def to_pos_integer(x) do
    value = to_integer(x)

    if value != nil and value > 0 do
      value
    else
      nil
    end
  end

  def to_integer(x) when is_binary(x) do
    case Integer.parse(x) do
      :error -> nil
      {x, _} -> x
    end
  end

  def to_integer(x) when is_number(x), do: trunc(x)

  def to_integer(x) when is_binary(x) do
    case Integer.parse(x) do
      :error -> nil
      {x, _} -> x
    end
  end

  def to_integer(_), do: nil

  def to_abs(x) do
    case to_float(x) do
      nil -> nil
      x -> abs(x)
    end
  end

  def to_non_empty_binary(""), do: nil
  def to_non_empty_binary(x), do: to_binary(x)

  def to_binary_unless(x, values) when is_list(values) do
    x = to_binary(x)
    if x in values, do: nil, else: x
  end

  def to_binary_unless(_x, values) when is_list(values), do: nil

  def to_binary(x), do: Helpers.serialize(x)

  def to_boolean(x) when is_boolean(x), do: x

  def to_boolean(x) when is_binary(x) do
    case x |> String.trim() |> Helpers.downcase() do
      "true" -> true
      "false" -> false
    end
  end

  def to_boolean(_), do: nil
end