defmodule Timex.Format.DateTime.Formatters.Relative do
  @moduledoc """
  Relative time, based on Moment.js

  Uses localized strings.

  The format string should contain {relative}, which is where the phrase will be injected.

  | Range	                     | Sample Output
  ---------------------------------------------------------------------
  | 0 seconds                  | now
  | 1 to 45 seconds	           | a few seconds ago
  | 45 to 90 seconds	         | a minute ago
  | 90 seconds to 45 minutes	 | 2 minutes ago ... 45 minutes ago
  | 45 to 90 minutes	         | an hour ago
  | 90 minutes to 22 hours	   | 2 hours ago ... 22 hours ago
  | 22 to 36 hours	           | a day ago
  | 36 hours to 25 days	       | 2 days ago ... 25 days ago
  | 25 to 45 days	             | a month ago
  | 45 to 345 days	           | 2 months ago ... 11 months ago
  | 345 to 545 days (1.5 years)  | a year ago
  | 546 days+	                 | 2 years ago ... 20 years ago
  """
  use Timex.Format.DateTime.Formatter
  use Combine
  alias Timex.Format.FormatError
  alias Timex.{Types, Translator}

  @spec tokenize(String.t()) :: {:ok, [Directive.t()]} | {:error, term}
  def tokenize(format_string) do
    case Combine.parse(format_string, relative_parser()) do
      results when is_list(results) ->
        directives = results |> List.flatten() |> Enum.filter(fn x -> x !== nil end)

        case Enum.any?(directives, fn %Directive{type: type} -> type != :literal end) do
          false -> {:error, "Invalid format string, must contain at least one directive."}
          true -> {:ok, directives}
        end

      {:error, _} = err ->
        err
    end
  end

  @doc """
  Formats a date/time as a relative time formatted string

  ## Examples

      iex> #{__MODULE__}.format(Timex.shift(Timex.now, minutes: -1), "{relative}")
      {:ok, "1 minute ago"}
  """
  @spec format(Types.calendar_types(), String.t()) :: {:ok, String.t()} | {:error, term}
  def format(date, format_string), do: lformat(date, format_string, Translator.current_locale())

  @spec format!(Types.calendar_types(), String.t()) :: String.t() | no_return
  def format!(date, format_string), do: lformat!(date, format_string, Translator.current_locale())

  @spec lformat(Types.calendar_types(), String.t(), String.t()) ::
          {:ok, String.t()} | {:error, term}
  def lformat(date, format_string, locale) do
    case tokenize(format_string) do
      {:ok, []} ->
        {:error, "There were no formatting directives in the provided string."}

      {:ok, dirs} when is_list(dirs) ->
        do_format(
          locale,
          Timex.to_naive_datetime(date),
          Timex.Protocol.NaiveDateTime.now(),
          dirs,
          <<>>
        )

      {:error, reason} ->
        {:error, {:format, reason}}
    end
  end

  @spec lformat!(Types.calendar_types(), String.t(), String.t()) :: String.t() | no_return
  def lformat!(date, format_string, locale) do
    case lformat(date, format_string, locale) do
      {:ok, result} -> result
      {:error, reason} -> raise FormatError, message: reason
    end
  end

  def relative_to(date, relative_to, format_string) do
    relative_to(date, relative_to, format_string, Translator.current_locale())
  end

  def relative_to(date, relative_to, format_string, locale) do
    case tokenize(format_string) do
      {:ok, []} ->
        {:error, "There were no formatting directives in the provided string."}

      {:ok, dirs} when is_list(dirs) ->
        do_format(
          locale,
          Timex.to_naive_datetime(date),
          Timex.to_naive_datetime(relative_to),
          dirs,
          <<>>
        )

      {:error, reason} ->
        {:error, {:format, reason}}
    end
  end

  @minute 60
  @hour @minute * 60
  @day @hour * 24
  @month @day * 30
  @year @month * 12

  defp do_format(_locale, _date, _relative, [], result), do: {:ok, result}

  defp do_format(locale, date, relative, [%Directive{type: :literal, value: char} | dirs], result)
       when is_binary(char) do
    do_format(locale, date, relative, dirs, <<result::binary, char::binary>>)
  end

  defp do_format(locale, date, relative, [%Directive{type: :relative} | dirs], result) do
    diff = Timex.diff(date, relative, :seconds)

    phrase =
      cond do
        # future
        diff == 0 ->
          Translator.translate(locale, "relative_time", "now")

        diff > 0 && diff <= 45 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} second",
            "in %{count} seconds",
            diff
          )

        diff > 45 && diff < @minute * 2 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} minute",
            "in %{count} minutes",
            1
          )

        diff >= @minute * 2 && diff < @hour ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} minute",
            "in %{count} minutes",
            div(diff, @minute)
          )

        diff >= @hour && diff < @hour * 2 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} hour",
            "in %{count} hours",
            1
          )

        diff >= @hour * 2 && diff < @day ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} hour",
            "in %{count} hours",
            div(diff, @hour)
          )

        diff >= @day && diff < @day * 2 ->
          Translator.translate(
            locale,
            "relative_time",
            "tomorrow"
          )

        diff >= @day * 2 && diff < @month ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} day",
            "in %{count} days",
            div(diff, @day)
          )

        diff >= @month && diff < @month * 2 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} month",
            "in %{count} months",
            1
          )

        diff >= @month * 2 && diff < @year ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} month",
            "in %{count} months",
            div(diff, @month)
          )

        diff >= @year && diff < @year * 2 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} year",
            "in %{count} years",
            1
          )

        diff >= @year * 2 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "in %{count} year",
            "in %{count} years",
            div(diff, @year)
          )

        # past
        diff < 0 && diff >= -45 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} second ago",
            "%{count} seconds ago",
            diff * -1
          )

        diff < -45 && diff > @minute * 2 * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} minute ago",
            "%{count} minutes ago",
            1
          )

        diff <= @minute * 2 && diff > @hour * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} minute ago",
            "%{count} minutes ago",
            div(diff * -1, @minute)
          )

        diff <= @hour && diff > @hour * 2 * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} hour ago",
            "%{count} hours ago",
            1
          )

        diff <= @hour * 2 && diff > @day * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} hour ago",
            "%{count} hours ago",
            div(diff * -1, @hour)
          )

        diff <= @day && diff > @day * 2 * -1 ->
          Translator.translate(
            locale,
            "relative_time",
            "yesterday"
          )

        diff <= @day * 2 && diff > @month * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} day ago",
            "%{count} days ago",
            div(diff * -1, @day)
          )

        diff <= @month && diff > @month * 2 * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} month ago",
            "%{count} months ago",
            1
          )

        diff <= @month * 2 && diff > @year * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} month ago",
            "%{count} months ago",
            div(diff * -1, @month)
          )

        diff <= @year && diff > @year * 2 * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} year ago",
            "%{count} years ago",
            1
          )

        diff <= @year * 2 * -1 ->
          Translator.translate_plural(
            locale,
            "relative_time",
            "%{count} year ago",
            "%{count} years ago",
            div(diff * -1, @year)
          )
      end

    do_format(locale, date, relative, dirs, <<result::binary, phrase::binary>>)
  end

  defp do_format(
         locale,
         date,
         relative,
         [%Directive{type: type, modifiers: mods, flags: flags, width: width} | dirs],
         result
       ) do
    case format_token(locale, type, date, mods, flags, width) do
      {:error, _} = err -> err
      formatted -> do_format(locale, date, relative, dirs, <<result::binary, formatted::binary>>)
    end
  end

  # Token parser
  defp relative_parser do
    many1(
      choice([
        between(char(?{), map(one_of(word(), ["relative"]), &map_directive/1), char(?})),
        map(none_of(char(), ["{", "}"]), &map_literal/1)
      ])
    )
  end

  # Gets/builds the Directives for a given token
  defp map_directive("relative"),
    do: %Directive{:type => :relative, :value => "relative"}

  # Generates directives for literal characters
  defp map_literal([]), do: nil

  defp map_literal(literals)
       when is_list(literals),
       do: Enum.map(literals, &map_literal/1)

  defp map_literal(literal), do: %Directive{type: :literal, value: literal, parser: char(literal)}
end