defmodule Fibonacci do
  def of(0), do: 0
  def of(1), do: 1
  def of(n), do: of(n-1) + of(n-2)
end

#Fibonacci.of(13) |> IO.inspect

defmodule Waste do
  def ms(n) do
    :timer.sleep(n)
    n
  end
end

defmodule Parallel do
  def map(enumerable, f) do
    master = self
    enumerable
    |> Enum.map(&task(&1, f))
    |> collect
  end

  defp collect(tasks) do
    timeout = 1_000
    reference = make_ref
    timer = Process.send_after(self, {:timeout, reference}, timeout)
    try do
      collect(tasks, [], reference)
    after
      :timer.cancel(timer)
      receive do
        {:timeout, ^reference} ->
          :ok
      after 0 ->
        :ok
      end
    end
  end

  defp collect([], results, _), do: results |> Enum.reverse
  defp collect(tasks, results, reference) do
    receive do
      {:timeout, ^reference} ->
        {:timeout, length(results), results}
      message ->
        case Task.find(tasks, message) do
          {result, task} ->
            collect(List.delete(tasks, task), [result|results], reference)
          nil ->
            collect(tasks, results, reference)
        end
    end
  end

    defp task(e, f) do
      master = self
      reference = make_ref
      spawn(fn -> send(master, {reference, f.(e)}) end)
    end

end

:random.seed(:os.timestamp)

0..10
|> Enum.map(fn _ -> :random.uniform(1_000) - 500 end)
#|> Parallel.map(&Fibonacci.of/1)
|> Parallel.map(&Waste.ms/1)
|> IO.inspect