quarrel

defmodule Quarrel.TestConsumer do
  @moduledoc """
  Replacement for Quarrel.NostrumConsumer during testing
  """

  require Logger
  use GenServer

  alias Nostrum.Struct.{
    Channel,
    Event.MessageDelete,
    Event.MessageDeleteBulk,
    Event.SpeakingUpdate,
    Guild,
    Guild.Member,
    Guild.Role,
    Guild.UnavailableGuild,
    Interaction,
    Message,
    User
  }

  alias Quarrel.GuildSupervisor

  @spec dispatch_event(Nostrum.Consumer.event()) :: :ok
  def dispatch_event(event) do
    GenServer.cast(__MODULE__, event)
  end

  @doc false
  def start_link(args) do
    GenServer.start_link(__MODULE__, args, name: __MODULE__)
  end

  @impl GenServer
  def init(_args) do
    {:ok, %{}}
  end

  @impl GenServer
  def handle_cast({:CHANNEL_CREATE, %Channel{guild_id: guild_id} = channel, _}, _) do
    dispatch(guild_id, :handle_channel_create, [channel])
  end

  def handle_cast({:CHANNEL_DELETE, %Channel{guild_id: guild_id} = channel, _}, _) do
    dispatch(guild_id, :handle_channel_delete, [channel])
  end

  def handle_cast({:CHANNEL_UPDATE, {old, %Channel{guild_id: guild_id} = channel}, _}, _) do
    dispatch(guild_id, :handle_channel_update, [old, channel])
  end

  def handle_cast({:CHANNEL_PINS_UPDATE, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_channel_pins_update, [map])
  end

  def handle_cast({:GUILD_BAN_ADD, {guild_id, %User{} = user}, _}, _) do
    dispatch(guild_id, :handle_guild_ban_add, [user])
  end

  def handle_cast({:GUILD_BAN_REMOVE, {guild_id, %User{} = user}, _}, _) do
    dispatch(guild_id, :handle_guild_ban_remove, [user])
  end

  def handle_cast({:GUILD_CREATE, %Guild{id: guild_id} = guild, _}, _) do
    dispatch(guild_id, :handle_guild_create, [guild])
  end

  def handle_cast({:GUILD_AVAILABLE, {%Guild{id: guild_id} = guild}, _}, _) do
    with {:ok, bot} <- Nostrum.Api.get_current_user(),
         {:ok, config} <- Quarrel.get_settings(guild),
         {:ok, _pid} <- GuildSupervisor.guild_available(guild, config, bot) do
      dispatch(guild_id, :handle_guild_available, [guild])
    else
      error ->
        Logger.error("GUILD_AVAILABLE failure: #{inspect(error)}")
    end
  end

  def handle_cast({:GUILD_UNAVAILABLE, %UnavailableGuild{id: guild_id} = unavailable_guild, _}, _) do
    _ = dispatch(guild_id, :handle_guild_unavailable, [unavailable_guild])
    GuildSupervisor.guild_unavailable(unavailable_guild)
  end

  def handle_cast(
        {:GUILD_UPDATE, {%Guild{id: guild_id} = old, %Guild{id: guild_id} = new_guild}, _},
        _
      ) do
    dispatch(guild_id, :handle_guild_update, [old, new_guild])
    GuildSupervisor.guild_update(old, new_guild)
  end

  def handle_cast({:GUILD_DELETE, {%Guild{id: guild_id} = guild, unavailable}, _}, _) do
    dispatch(guild_id, :handle_guild_delete, [guild, unavailable])
    GuildSupervisor.guild_delete(guild)
  end

  def handle_cast({:GUILD_EMOJIS_UPDATE, {guild_id, old_emojis, new_emojis}, _}, _) do
    dispatch(guild_id, :handle_guild_emojis_update, [old_emojis, new_emojis])
  end

  def handle_cast({:GUILD_INTERACTIONS_UPDATE, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_guild_interactions_update, [map])
  end

  def handle_cast({:GUILD_MEMBER_ADD, {guild_id, %Member{} = member}, _}, _) do
    dispatch(guild_id, :handle_guild_member_add, [member])
  end

  def handle_cast({:GUILD_MEMBERS_CHUNK, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_guild_members_chunk, [map])
  end

  def handle_cast({:GUILD_MEMBER_REMOVE, {guild_id, %Member{} = old_member}}, _) do
    dispatch(guild_id, :handle_guild_member_remove, [old_member])
  end

  def handle_cast({:GUILD_MEMBER_UPDATE, {guild_id, %Member{} = old, %Member{} = new}, _}, _) do
    dispatch(guild_id, :handle_guild_member_update, [old, new])
  end

  def handle_cast({:GUILD_ROLE_CREATE, {guild_id, %Role{} = role}, _}, _) do
    dispatch(guild_id, :handle_guild_role_create, [role])
  end

  def handle_cast({:GUILD_ROLE_DELETE, {guild_id, %Role{} = old_role}, _}, _) do
    dispatch(guild_id, :handle_guild_role_delete, [old_role])
  end

  def handle_cast({:GUILD_ROLE_UPDATE, {guild_id, old_role, new_role}, _}, _) do
    dispatch(guild_id, :handle_guild_role_update, [old_role, new_role])
  end

  def handle_cast({:INTERACTION_CREATE, %Interaction{guild_id: guild_id} = interaction, _}, _) do
    dispatch(guild_id, :handle_interaction_create, [interaction])
  end

  def handle_cast({:MESSAGE_CREATE, %Message{guild_id: guild_id} = message, _}, _) do
    dispatch(guild_id, :handle_message_create, [message])
  end

  def handle_cast({:MESSAGE_DELETE, %MessageDelete{guild_id: guild_id} = message_delete, _}, _) do
    dispatch(guild_id, :handle_message_delete, [message_delete])
  end

  def handle_cast(
        {:MESSAGE_DELETE_BULK, %MessageDeleteBulk{guild_id: guild_id} = message_delete_bulk, _},
        _
      ) do
    dispatch(guild_id, :handle_message_delete_bulk, [message_delete_bulk])
  end

  def handle_cast({:MESSAGE_UPDATE, %Message{guild_id: guild_id} = message, _}, _) do
    dispatch(guild_id, :handle_message_update, [message])
  end

  def handle_cast({:MESSAGE_REACTION_ADD, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_message_reaction_add, [map])
  end

  def handle_cast({:MESSAGE_REACTION_REMOVE, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_message_reaction_remove, [map])
  end

  def handle_cast({:MESSAGE_REACTION_REMOVE_ALL, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_message_reaction_remove_all, [map])
  end

  def handle_cast({:MESSAGE_REACTION_REMOVE_EMOJI, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_message_reaction_remove, [map])
  end

  def handle_cast({:MESSAGE_ACK, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_message_ack, [map])
  end

  def handle_cast({:PRESENCE_UPDATE, {guild_id, old_presence, new_presence}, _}, _) do
    dispatch(guild_id, :handle_presence_update, [old_presence, new_presence])
  end

  def handle_cast({:READY, map, _}, _) do
    dispatch(:handle_ready, [map])
  end

  def handle_cast({:RESUMED, map, _}, _) do
    dispatch(:handle_resumed, [map])
  end

  def handle_cast({:TYPING_START, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_typing_start, [map])
  end

  def handle_cast({:USER_UPDATE, {old_user, %User{} = new_user}, _}, _) do
    dispatch(:handle_user_update, [old_user, new_user])
  end

  def handle_cast(
        {:VOICE_SPEAKING_UPDATE, %SpeakingUpdate{guild_id: guild_id} = speaking_update, _},
        _
      ) do
    dispatch(guild_id, :handle_voice_speaking_update, [speaking_update])
  end

  def handle_cast({:VOICE_STATE_UPDATE, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_voice_state_update, [map])
  end

  def handle_cast({:VOICE_SERVER_UPDATE, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_voice_server_update, [map])
  end

  def handle_cast({:WEBHOOKS_UPDATE, %{guild_id: guild_id} = map, _}, _) do
    dispatch(guild_id, :handle_webhooks_update, [map])
  end

  def handle_cast(event, state) do
    Logger.error("Unhandled Event from Discord Gateway: #{inspect(event)}")
    {:noreply, state}
  end

  @spec dispatch(integer, atom, [term]) :: any()
  defp dispatch(guild_id, function, args) do
    Phoenix.PubSub.broadcast(
      Quarrel.PubSub,
      "guild:#{guild_id}",
      {Quarrel.NostrumConsumer, function, args}
    )

    {:noreply, nil}
  end

  @spec dispatch(atom, [term]) :: any()
  defp dispatch(function, args) do
    Phoenix.PubSub.broadcast(Quarrel.PubSub, "guild", {Quarrel.NostrumConsumer, function, args})
    {:noreply, nil}
  end
end