ex_video_factory

defmodule ExVideoFactory do
  @moduledoc """
  Documentation for ExVideoFactory.
  """

  @doc """
  Get the list of videos.

  """
  def videos(query \\ %{}) do
    page =
      Map.get(query, "page", 1)
      |> force_integer
    page_size =
      Map.get(query, "per_page", 20)
      |> force_integer
    query =
      query
      |> format_query

    response = ExVideoFactory.Client.get("videos", [query: query])
    total = get_total_number_of_elements(response)
    list = response.body
    %{
      videos: list,
      size: length(list),
      offset: (page - 1) * page_size + 1,
      total: total
    }
  end

  @doc """
  Get the list of regions.

  """
  def regions do
    response = ExVideoFactory.Client.get("regions")
    list = response.body
    total = get_total_number_of_elements(response)
    %{
      regions: list,
      size: length(list),
      total: total
    }
  end

  @doc """
  Get the list of types.

  """
  def types do
    response = ExVideoFactory.Client.get("types")
    list = response.body
    total = get_total_number_of_elements(response)
    %{
      types: list,
      size: length(list),
      total: total
    }
  end

  @doc """
  Get the list of channels.

  """
  def channels do
    response = ExVideoFactory.Client.get("channels")
    list = response.body
    total = get_total_number_of_elements(response)
    %{
      channels: list,
      size: length(list),
      total: total
    }
  end

  defp get_total_number_of_elements(response) do
    response.headers['X-Total-Count']
  end

  defp force_integer(param) when is_bitstring(param) do
    param
    |> String.to_integer
  end

  defp force_integer(param) do
    param
  end


  def format_query(query) do
    query
    |> Enum.map(fn {key, value} ->
        format_field(key, value)
      end
      )
    |> Map.new
  end

  defp format_field(key, value) do
    format_field(key, String.split(key, "_"), value)
  end

  defp format_field(_, [prefix, "after"], value) do
    {prefix <> "_at[gte]", format_iso8601(value)}
  end

  defp format_field(_, [prefix, "before"], value) do
    {prefix <> "_at[lte]", format_iso8601(value)}
  end

  defp format_field("channels[]", _, value) do
    {"channel.id[in]", value}
  end

  defp format_field(key, _, value) do
    {key, value}
  end

  defp format_iso8601(date) do
    char = String.at(date, 19)
    case char do
      " " ->
        String.replace(date, ~r/\s/, "+")
      nil ->
        raise ArgumentError, message: "Unsupported date format: " <> date
      _ ->
        date
    end
  end


  def get_files_for_id_diffusion(id_diffusion) do
    query = [idDiffusion: id_diffusion]
    ExVideoFactory.LegacyClient.get("getInfosOeuvre/v2/", [query: query]).body
    |> get_files
  end

  def get_files(content) do
    content
    |> Map.get("videos")
    |> format_files([])
  end

  defp format_files([], list), do: list
  defp format_files([item | items], list) do
    list =
      case item do
        %{"format" => _format, "url" => nil} ->
          list
        %{"format" => format, "url" => url} ->
          item = %{
            format: format,
            urls: format_url(url)
          }
          List.insert_at(list, -1, item)
      end
    format_files(items, list)
  end

  defp format_url("http://replayftv-vh.akamaihd.net/i/" <> url) do
    list = String.split(url, ",")

    [base_root, _extension] =
      Enum.filter(list, fn(item) -> ! is_standard(item) end)

    qualities =
      Enum.filter(list, fn(item) -> is_standard(item) end)

    for quality <- qualities do
      "/343079/http/#{base_root}#{quality}.mp4"
    end
  end

  defp format_url(url) do
    []
  end


  defp is_standard("standard" <> _id), do: true
  defp is_standard(something), do: false
end