defmodule ShardWeb.RoomChannel do
  use ShardWeb, :channel

  require Logger

  def join("room:" <> room_name, payload, socket) do
    if authorized?(payload) do

      list = for {_chid, manifest, chpid} <- Shard.Manager.list_shards,
                 %SApp.Chat.Manifest{channel: chan} = manifest,
                 do: {chan, chpid}
      pid = case List.keyfind(list, room_name, 0) do
        nil ->
          {:ok, pid} = DynamicSupervisor.start_child(Shard.DynamicSupervisor, {SApp.Chat, room_name})
          pid
        {_, pid} ->
          pid
      end
      socket = assign(socket, :pid, pid)

      GenServer.cast(pid, {:subscribe, self()})
      send(self(), :after_join)
      
      {:ok, socket}
    else
      {:error, %{reason: "unauthorized"}}
    end
  end

  def handle_info(:after_join, socket) do
    GenServer.call(socket.assigns.pid, {:read_history, nil, 100})
    |> Enum.each(fn {{_ts, nick, msg}, true} -> push(socket, "shout", %{
        name: nick,
        message: msg,
    }) end)
    {:noreply, socket}
  end

  def handle_info({:chat_recv, _chan, {_ts, from, msg}}, socket) do
    Logger.info("#{inspect self()} :chat_recv #{inspect msg}")
    push socket, "shout", %{"name" => from, "message" => msg}
    {:noreply, socket}
  end

  def handle_info({:chat_send, _, _}, socket) do
    {:noreply, socket}
  end

  # Channels can be used in a request/response fashion
  # by sending replies to requests from the client
  def handle_in("ping", payload, socket) do
    {:reply, {:ok, payload}, socket}
  end

  # It is also common to receive messages from the client and
  # broadcast to everyone in the current topic (room:lobby).
  def handle_in("shout", payload, socket) do
    broadcast socket, "shout", payload
    Shard.Identity.set_nickname(payload["name"])
    GenServer.cast(socket.assigns.pid, {:chat_send, payload["message"]})
    {:noreply, socket}
  end

  # Add authorization logic here as required.
  defp authorized?(_payload) do
    true
  end
end