bingex

defmodule Bingex.Swap.PriceSocket do
  @moduledoc ~S"""
  ```elixir
  defmodule PriceSource do
    use Bingex.Swap.PriceSocket
    alias Bingex.Swap.PriceSocket

    def start_link(_args \\ []) do
      PriceSocket.start_link(__MODULE__, :state)
    end

    @impl true
    def handle_connect(state) do
      PriceSocket.subscribe(symbol: "BTC-USDT", type: :last)
      {:ok, state}
    end

    @impl true
    def handle_event(type, event, state) do
      IO.inspect({type, event, state})
      {:ok, state}
    end
  end
  ```
  """

  alias Bingex.Socket
  alias Bingex.Swap.Model.PriceEvent

  @origin Application.compile_env(
            :bingex,
            :swap_origin,
            "wss://open-api-swap.bingx.com/swap-market"
          )

  @callback handle_event(
              type :: :price,
              event :: PriceEvent.t(),
              state :: term()
            ) :: {:ok, state :: term()} | {:close, state :: term()}

  @doc false
  defmacro __using__(opts \\ []) do
    quote location: :keep, bind_quoted: [opts: opts] do
      @behaviour Bingex.Socket
      @behaviour Bingex.Swap.PriceSocket

      @doc false
      def child_spec(arg) do
        default = %{
          id: __MODULE__,
          start: {__MODULE__, :start_link, [arg]}
        }

        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
      end

      @impl true
      def handle_event(event, state) do
        case PriceEvent.decode(event) do
          {:ok, event} -> handle_event(:price, event, state)
          :error -> {:ok, state}
        end
      end

      @impl true
      def handle_event(type, event, state) do
        raise "handle_event/3 not implemented"
      end

      defoverridable child_spec: 1,
                     handle_event: 3
    end
  end

  def start_link(module, state, options \\ []) do
    Socket.start_link(@origin, module, state, options)
  end

  def start(module, state, options \\ []) do
    Socket.start(@origin, module, state, options)
  end

  def call(pid, message, delay) do
    Socket.call(pid, message, delay)
  end

  def cast(pid, message) do
    Socket.cast(pid, message)
  end

  def subscribe(pid \\ self(), params) do
    symbol = params[:symbol]
    type = params[:type]

    channel =
      """
      {
        \"id\": \"24dd0e35-56a4-4f7a-af8a-394c7060909c\",
        \"reqType\": \"sub\",
        \"dataType\": \"#{symbol}@#{type}Price\"
      }
      """

    Bingex.Socket.send(pid, channel)
  end
end