defmodule Speedtest do
  @moduledoc """
  Speedtest.net client for Elixir.
  """

  alias Speedtest.Ping

  alias Speedtest.Decoder

  alias Speedtest.Result

  require Logger

  @ttl 25000

  defstruct config: [],
            servers: [],
            include: nil,
            exclude: nil,
            threads: nil,
            selected_server: nil,
            result: nil

  @doc """
  Retrieve a the list of speedtest.net servers, optionally filtered
   to servers matching those specified in the servers argument

    ## Examples

       iex> Speedtest.fetch_servers(%Speedtest{})

  """
  def fetch_servers(%Speedtest{} = speedtest \\ %Speedtest{}) do
    Logger.info("Retrieving speedtest.net server list...")

    urls = [
      "https://www.speedtest.net/speedtest-servers-static.php",
      "http://c.speedtest.net/speedtest-servers-static.php",
      "https://www.speedtest.net/speedtest-servers.php",
      "http://c.speedtest.net/speedtest-servers.php"
    ]

    first = List.first(urls)

    {_, response} = fetch_server(first)

    result = Decoder.server(response)

    result =
      case speedtest.include == nil do
        true -> result
        false -> Enum.reject(speedtest.include, fn x -> Enum.member?(result, x) == false end)
      end

    result =
      case speedtest.exclude == nil do
        true -> result
        false -> Enum.reject(speedtest.exclude, fn x -> Enum.member?(result, x) end)
      end

    reply = %{speedtest | servers: result}
    {:ok, reply}
  end

  @doc """
  Limit servers to the closest speedtest.net servers based on
  geographic distance

    ## Examples

       iex> Speedtest.choose_closest_servers()
      
  """
  def choose_closest_servers(servers \\ [], amount \\ 2) do
    Enum.sort_by(servers, fn s -> s.distance end)
    |> Enum.take(amount)
  end

  @doc """
  Perform a speedtest.net "ping" to determine which speedtest.net
  server has the lowest latency

    ## Examples

      iex> Speedtest.choose_best_server([])
      
  """
  def choose_best_server(servers) do
    Logger.info("Selecting best server based on ping...")

    Enum.map(servers, fn s ->
      url = Decoder.url(s.host)
      ping = Speedtest.Ping.ping(url)
      Map.put(s, :ping, ping)
    end)
    |> Enum.sort_by(fn s -> s.ping end)
    |> List.first(servers)
  end

  @doc """
  Test download speed against speedtest.net

  ## Examples

    iex> Speedtest.download(%Speedtest{})

  """
  def download(%Speedtest{} = speedtest \\ %Speedtest{}) do
    Logger.info("Testing download speed...")
    {_, urls} = generate_download_urls(speedtest)

    threads =
      case is_nil(speedtest.threads) do
        true -> speedtest.config.threads.download
        false -> speedtest.threads
      end

    urls = Enum.chunk_every(urls, threads)

    responses =
      Enum.map(urls, fn data ->
        Enum.map(data, fn url ->
          timed_fetch(url)
        end)
        |> Task.await_many(@ttl)
      end)
      |> List.flatten()

    {:ok, responses}
  end

  defp timed_fetch(url) do
    Task.async(fn ->
      {time_in_microseconds, return} =
        :timer.tc(fn ->
          {_, reply} = HTTPoison.get(url, [], recv_timeout: @ttl)
          reply
        end)

      [{_, length}] =
        Enum.filter(return.headers, fn h ->
          {key, _} = h
          key == "Content-Length"
        end)

      time_in_seconds = time_in_microseconds / 1_000_000

      %{elapsed_time: time_in_seconds, bytes: String.to_integer(length), url: url}
    end)
  end

  defp timed_post(url, size) do
    Task.async(fn ->
      event_time = System.monotonic_time(:millisecond)

      headers = [{"Content-length", size}]
      body = ""
      HTTPoison.post(url, body, headers, recv_timeout: @ttl)

      time_in_milliseconds = System.monotonic_time(:millisecond) - event_time

      %{elapsed_time: time_in_milliseconds / 1_000, bytes: size, url: url}
    end)
  end

  @doc """
  Test upload speed against speedtest.net

  ## Examples

    iex> Speedtest.upload(%Speedtest{})

  """
  def upload(%Speedtest{} = speedtest \\ %Speedtest{}) do
    Logger.info("Testing Upload Speed...")
    {_, data} = generate_upload_data(speedtest)

    threads =
      case is_nil(speedtest.threads) do
        true -> speedtest.config.threads.upload
        false -> speedtest.threads
      end

    data = Enum.chunk_every(data, threads)

    responses =
      Enum.map(data, fn data ->
        Enum.map(data, fn {url, size} ->
          timed_post(url, size)
        end)
        |> Task.await_many(@ttl)
      end)
      |> List.flatten()

    {:ok, responses}
  end

  @doc """
  Determine distance between sets of [lat,lon] in km 

  ## Examples

    iex> Speedtest.distance(%Speedtest{})

  """
  def distance(%Speedtest{} = speedtest \\ %Speedtest{}) do
    servers =
      Enum.map(speedtest.servers, fn s ->
        distance =
          Geocalc.distance_between([speedtest.config.client.lat, speedtest.config.client.lon], [
            s.lat,
            s.lon
          ])
          |> Float.round()
          |> trunc()

        Map.put(s, :distance, distance)
      end)

    speedtest = %{speedtest | servers: servers}
    {:ok, speedtest}
  end

  @doc """
  Run the full speedtest.net test

  ## Examples

    iex> Speedtest.run()

  """
  def run() do
    {_, init} = init()

    {_, result} = fetch_config_data()

    config = Decoder.config(result)

    Logger.info("Testing from " <> config.client.isp <> " (" <> config.client.ip <> ")...")

    {_, result} = fetch_servers(init)

    speedtest = %{result | config: config}

    {_, result} = distance(speedtest)

    closest_servers = choose_closest_servers(result.servers)

    selected_server = choose_best_server(closest_servers)

    {status, _, response} = selected_server.ping

    reply =
      case status do
        :ok ->
          ping = to_string(response)

          elapsed_time = ping <> " ms"

          Logger.info(
            "Hosted by " <>
              selected_server.sponsor <>
              " (" <>
              selected_server.name <>
              ") " <>
              "[" <>
              to_string(Float.round(selected_server.distance / 1000)) <> " km]: " <> elapsed_time
          )

          speedtest = %{result | selected_server: selected_server}

          {_, download_reply} = download(speedtest)

          {_, upload_reply} = upload(speedtest)

          replys = {upload_reply, download_reply}

          {_, reply} = Result.create(speedtest, replys)

          speed = to_string(reply.result.download) <> " Mbit/s"
          Logger.info("Download: " <> speed)

          speed = to_string(reply.result.upload) <> " Mbit/s"
          Logger.info("Upload: " <> speed)

          config = reply.config

          client = reply.result.client

          config = %{config | client: client}

          %{reply | config: config}

        _ ->
          response
      end

    {status, reply}
  end

  @doc """
  Ping an IP and return a tuple with the time

  ## Examples

    iex> Speedtest.ping("127.0.0.1")

  """
  def ping(ip) do
    Ping.ping(ip)
  end

  @doc """
  Setup the base speedtest

  ## Examples

    iex> Speedtest.init()
    {:ok, %Speedtest{config: [],exclude: nil,include: nil,result: nil,selected_server: nil,servers: [],threads: nil}}


  """
  def init() do
    threads = Application.get_env(:speedtest, :threads)
    include = Application.get_env(:speedtest, :include)
    exclude = Application.get_env(:speedtest, :exclude)
    st = %Speedtest{}
    reply = %{st | threads: threads, include: include, exclude: exclude}
    {:ok, reply}
  end

  defp generate_download_urls(%Speedtest{} = speedtest) do
    urls =
      Enum.map(speedtest.config.sizes.download, fn s ->
        size = to_string(s)
        speedtest.selected_server.host <> "/speedtest/random" <> size <> "x" <> size <> ".jpg"
      end)

    urls = Enum.shuffle(urls)

    {:ok, urls}
  end

  defp generate_upload_data(%Speedtest{} = speedtest) do
    data =
      Enum.map(speedtest.config.sizes.upload, fn s ->
        {speedtest.selected_server.url, to_string(s)}
      end)

    {:ok, data}
  end

  defp user_agent() do
    {"User-Agent",
     "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.117 Safari/537.36"}
  end

  defp fetch_server(server) do
    HTTPoison.get(server, [user_agent()], hackney: [headers: [user_agent()]])
  end

  defp fetch_config_data() do
    Logger.info("Retrieving speedtest.net configuration...")

    {status, response} =
      HTTPoison.get(
        "https://www.speedtest.net/speedtest-config.php",
        [user_agent()],
        hackney: [headers: [user_agent()]]
      )

    {status, response}
  end
end