bingex

defmodule Bingex.Swap.EventSocket do
  @moduledoc ~S"""
  ```elixir
  defmodule EventSource do
    use Bingex.Swap.EventSocket
    require Logger
    alias Bingex.Swap.EventSocket

    def start_link(listen_key) do
      EventSocket.start_link(listen_key, __MODULE__, :state)
    end

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

  alias Bingex.Socket
  alias Bingex.Swap.Model.{AccountEvent, TradeEvent, ConfigEvent}

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

  @callback handle_event(
              type :: :config | :account | :trade,
              event :: ConfigEvent.t() | AccountEvent.t() | TradeEvent.t(),
              state :: term()
            ) :: {:ok, state :: term()} | {:close, state :: term()}

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

      @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(%{"e" => "ACCOUNT_CONFIG_UPDATE"} = data, state) do
        case ConfigEvent.decode(data) do
          {:ok, event} -> handle_event(:config, event, state)
          :error -> {:ok, state}
        end
      end

      @impl true
      def handle_event(%{"e" => "ORDER_TRADE_UPDATE"} = data, state) do
        case TradeEvent.decode(data) do
          {:ok, event} -> handle_event(:trade, event, state)
          :error -> {:ok, state}
        end
      end

      @impl true
      def handle_event(%{"e" => "ACCOUNT_UPDATE"} = data, state) do
        case AccountEvent.decode(data) do
          {:ok, event} -> handle_event(:account, event, state)
          :error -> {:ok, state}
        end
      end

      @impl true
      def handle_event(_event, state) do
        {:ok, state}
      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(listen_key, module, state, options \\ []) do
    url = prepare_url(listen_key)
    Socket.start_link(url, module, state, options)
  end

  def start(listen_key, module, state, options \\ []) do
    url = prepare_url(listen_key)
    Socket.start(url, 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

  defp prepare_url(listen_key) do
    @origin <> "?listenKey=#{listen_key}"
  end
end