defmodule TelnetChat.BroadcasterTest do
  use ExUnit.Case, async: false
  use GenDebug

  alias TelnetChat.Broadcaster

  @moduletag :capture_log

  doctest Broadcaster

  @host 'localhost'
  @port 4040
  @client_opts [:binary, active: false]

  setup do
    {:ok, server} = :gen_tcp.listen(@port, [:binary, packet: :line, active: false, reuseaddr: true])

    {:ok, pid} = Broadcaster.start_link([])

    on_exit fn ->
      Process.exit(pid, :die)
    end

    {:ok, pid: pid}
  end

  test "module exists" do
    assert is_list(Broadcaster.module_info())
  end

  test "should register", %{pid: pid} do
    Broadcaster.register(:client)

    assert state(pid) == [:client]
  end

  test "should deregister", %{pid: pid} do
    Broadcaster.register(:client3)
    Broadcaster.register(:client2)
    Broadcaster.register(:client1)

    Broadcaster.deregister(:client2)

    assert state(pid) == [:client1, :client3]
  end

  test "should broadcast", %{pid: pid} do
    expected_message = "test line"

    {:ok, client1} = :gen_tcp.connect(@host, @port, @client_opts)
    {:ok, client2} = :gen_tcp.connect(@host, @port, @client_opts)
    {:ok, client3} = :gen_tcp.connect(@host, @port, @client_opts)

    Broadcaster.register(client3)
    Broadcaster.register(client2)
    Broadcaster.register(client1)

    wait_until_register_all_clients([client1, client2, client3])

    spawn_link fn  -> assert_receive_payload(expected_message, client2) end

    Broadcaster.broadcast(expected_message, client1)

    Process.sleep(2000)
  end

  defp assert_receive_payload(expected, client) do
    {:ok, actual} = :gen_tcp.recv(client, 0, 1000)

    assert actual == expected
  end

  defp wait_until_register_all_clients(clients) do
    Process.sleep(100)


    cond do
      Enum.sort(clients) ==  Enum.sort(state(Process.whereis(Broadcaster)))  -> :ok
      true -> wait_until_register_all_clients(clients)
    end
  end



end