if match?({:module, _}, Code.ensure_compiled(Cldr.Unit)) do
  defmodule Cldr.HTML.Unit do
    @moduledoc """
    Implements an HTML Form select specifically
    localised unit display.

    """

    @type select_options :: [
            {:units, [atom() | binary(), ...]}
            | {:locale, Cldr.Locale.locale_name() | Cldr.LanguageTag.t()}
            | {:collator, function()}
            | {:mapper, (Cldr.Unit.t() -> String.t())}
            | {:backend, module()}
            | {:selected, atom() | binary()}
          ]

    @doc """
    Generate an HTML select tag for a unit list
    that can be used with a `t:Phoenix.HTML.Form.t/0`.

    ## Arguments

    * A `t:Phoenix.HTML.Form.t/0` form

    * A `t:Phoenix.HTML.Form.field/0` field

    * A `t:Keyword` list of options

    ## Options

    For select options see `Phoenix.HTML.Form.options_for_select/2`

    * `:units` is a list of units to be displayed in the
      select. See `Cldr.Unit.known_units/0` and
      `Cldr.Unit.known_units_for_category/1`

    * `:style` is the style of unit name to be displayed and
      must be one of the styles returned by `Cldr.Unit.known_styles/0`.
      The current styles are :long, :short and :narrow.
      The default is style: :long.

    * `:locale` defines the locale to be used to localise the
      description of the units.  The default is the locale
      returned by `Cldr.get_locale/0`

    * `:backend` is any backend module. The default is
      `Cldr.default_backend!/0`

    * `:collator` is a function used to sort the units
      in the selection list. It is passed a list of tuples where
      each tuple is in the form `{unit_display_name, unit}`.
      The default collator sorts by `name_1 < name_2`.
      As a result, default collation sorts by code point which
      will not return expected results for scripts other than Latin.

    * `:mapper` is a function that creates the text to be
      displayed in the select tag for each unit.  It is
      passed the a tuple of the form `{unit_display_name, unit}`,
      The default is the identity function `&(&1)`.

    * `:selected` identifies the unit that is to be selected
      by default in the `select` tag.  The default is `nil`. This
      is passed unmodified to the form generator.

    * `:prompt` is a prompt displayed at the top of the select
       box. This is passed unmodified to the form generator.

    # Examples

         => Cldr.HTML.Unit.select(:my_form, :unit, selected: :foot)
         => Cldr.HTML.Unit.select(:my_form, :unit, units: [:foot, :inch])

    """
    @spec select(
            form :: Phoenix.HTML.Form.t(),
            field :: Phoenix.HTML.Form.field(),
            select_options
          ) ::
            Phoenix.HTML.safe()
            | {:error, {Cldr.UnknownUnitError, binary()}}
            | {:error, {Cldr.UnknownLocaleError, binary()}}

    def select(form, field, options \\ [])

    def select(form, field, options) when is_list(options) do
      select(form, field, validate_options(options), options[:selected])
    end

    @doc """
    Generate a list of options for a unit list
    that can be used with `Phoenix.HTML.Form.options_for_select/2` or
    to create a <datalist>.

    ## Arguments

    * A `t:Keyword.t/0` list of options,

    ## Options

    See `Cldr.HTML.Unit.select/3` for options.

    """
    @spec unit_options(select_options) ::
            list(tuple())
            | {:error, {Cldr.UnknownUnitError, binary()}}
            | {:error, {Cldr.UnknownLocaleError, binary()}}

    def unit_options(options \\ [])

    def unit_options(options) when is_list(options) do
      options
      |> validate_options()
      |> build_unit_options()
    end

    # Invalid options
    defp select(_form, _field, {:error, reason}, _selected) do
      {:error, reason}
    end

    @omit_from_select_options [:units, :locale, :mapper, :collator, :backend, :style]

    # Selected territory
    defp select(form, field, options, _selected) do
      select_options =
        options
        |> Map.drop(@omit_from_select_options)
        |> Map.to_list()

      options = build_unit_options(options)

      to_select(form, field, options, select_options)
    end

    if function_exported?(Phoenix.HTML.Form, :select, 4) do
      defp to_select(form, field, options, select_options) do
        Phoenix.HTML.Form.select(form, field, options, select_options)
      end
    else
      defp to_select(form, field, options, select_options) do
        {selected, select_options} = Keyword.pop(select_options, :selected)

        safe_options =
          options
          |> Phoenix.HTML.Form.options_for_select(selected)
          |> Phoenix.HTML.safe_to_string()

        safe_attrs =
          [
            id: Phoenix.HTML.Form.input_id(form, field),
            name: Phoenix.HTML.Form.input_name(form, field)
          ]
          |> Keyword.merge(select_options)
          |> Enum.sort()
          |> Phoenix.HTML.attributes_escape()
          |> Phoenix.HTML.safe_to_string()

        ["<select", safe_attrs, ?>, safe_options, "</select>"]
        |> IO.iodata_to_binary()
        |> Phoenix.HTML.raw()
      end
    end

    defp validate_options(options) do
      with options <- Map.merge(default_options(), Map.new(options)),
           {:ok, options} <- validate_locale(options),
           {:ok, options} <- validate_selected(options),
           {:ok, options} <- validate_units(options),
           {:ok, options} <- validate_style(options) do
        options
      end
    end

    defp default_options do
      Map.new(
        units: default_unit_list(),
        backend: nil,
        locale: Cldr.get_locale(),
        collator: &default_collator/1,
        mapper: & &1,
        style: :long,
        selected: nil
      )
    end

    defp default_collator(units) do
      Enum.sort(units, &default_comparator/2)
    end

    # Note that this is not a unicode aware comparison
    # It sorts by the display name
    defp default_comparator({_, unit_1}, {_, unit_2}) do
      unit_1 < unit_2
    end

    defp validate_selected(%{selected: nil} = options) do
      {:ok, options}
    end

    defp validate_selected(%{selected: selected} = options) do
      with {:ok, unit, _conversion} <- Cldr.Unit.validate_unit(selected) do
        {:ok, Map.put(options, :selected, unit)}
      end
    end

    # Return a list of validated units or an error
    defp validate_units(%{units: units} = options) do
      validate_units(units, options)
    end

    defp validate_units(units) when is_list(units) do
      Enum.reduce_while(units, [], fn unit, acc ->
        case Cldr.Unit.validate_unit(unit) do
          {:ok, unit, _conversion} -> {:cont, [unit | acc]}
          {:error, reason} -> {:halt, {:error, reason}}
        end
      end)
    end

    defp validate_units(units, options) do
      case validate_units(units) do
        {:error, reason} -> {:error, reason}
        units -> {:ok, Map.put(options, :units, Enum.reverse(units))}
      end
    end

    defp validate_style(options) do
      with {:ok, style} <- Cldr.Unit.validate_style(options[:style]) do
        {:ok, Map.put(options, :style, style)}
      end
    end

    defp validate_locale(options) do
      {locale, backend} = Cldr.locale_and_backend_from(options[:locale], options[:backend])

      with {:ok, locale} <- Cldr.validate_locale(locale, backend) do
        options
        |> Map.put(:locale, locale)
        |> Map.put(:backend, locale.backend)
        |> wrap(:ok)
      end
    end

    defp wrap(term, atom) do
      {atom, term}
    end

    defp maybe_include_selected_unit(%{selected: nil} = options) do
      options
    end

    defp maybe_include_selected_unit(%{units: units, selected: selected} = options) do
      if Enum.any?(units, &(&1 == selected)) do
        options
      else
        Map.put(options, :units, [selected | units])
      end
    end

    defp build_unit_options(options) when is_map(options) do
      options = maybe_include_selected_unit(options)

      units = Map.fetch!(options, :units)
      collator = Map.fetch!(options, :collator)
      mapper = Map.fetch!(options, :mapper)
      options = Map.to_list(options)

      units
      |> Enum.map(&to_selection_tuple(&1, options))
      |> collator.()
      |> Enum.map(&mapper.(&1))
    end

    defp to_selection_tuple(unit, options) do
      display_name = Cldr.Unit.display_name(unit, options)
      unit_code = to_string(unit)
      {display_name, unit_code}
    end

    defp default_unit_list() do
      Cldr.Unit.known_units()
    end
  end
end