magnolia

defmodule Magnolia.Shard do
  use WebSockex
  require Logger

  @properties %{
    os: "BEAM",
    browser: "Magnolia",
    device: "Magnolia"
  }

  defstruct [:zlib, :seq, :token]

  def start_link(url, token) do
    WebSockex.start_link(url, __MODULE__, token)
  end

  def handle_connect(_, token) do
    zlib = :zlib.open()
    :zlib.inflateInit(zlib)
    {:ok, %__MODULE__{zlib: zlib, seq: nil, token: token}}
  end

  def handle_frame({:binary, msg}, state) do
    payload = :zlib.inflate(state.zlib, msg)
      |> :erlang.iolist_to_binary()
      |> :erlang.binary_to_term()

    case handle_payload(payload, state) do
      :ok -> {:ok, state}
      {:reply, frame} -> {:reply, frame, state}
    end
  end

  def handle_info(:heartbeat, state) do
    resp = Jason.encode!(%{op: 1, d: state.seq}) |> IO.inspect
    {:reply, {:text, resp}, state}
  end

  def handle_payload(%{op: 10, d: %{heartbeat_interval: interval}}, state) do
    Logger.debug("HELLO")
    :timer.apply_interval(interval, Kernel, :send, [self(), :heartbeat])
    resp = :erlang.term_to_binary(%{op: 2, d: %{token: state.token, properties: @properties, compress: true, intents: 7}})
    :erlang.binary_to_term(resp) |> IO.inspect
    {:reply, {:binary, resp}}
  end

  def handle_payload(%{op: 11}, _) do
    Logger.debug("Heartbeat ACK")
    :ok
  end

  def handle_payload(payload, _) do
    Logger.debug(inspect payload)
    :ok
  end
end