defmodule Image.Text do
  @moduledoc """
  Functions for the creation of images from text.

  """

  alias Vix.Vips.Image, as: Vimage
  alias Vix.Vips.Operation
  alias Image.Options

  @doc """
  Create a new image from the provided string and
  formatting options.

  `text/2` creates an image with the
  following steps:

  * Render the text
  * Add an optional background color
  * Expand the background according to the required padding

  The text can be rendered as a positive (the default)
  in which an image of the provided string is rendered
  in the provided font, weight, size, fill color and
  stroke color.

  It can also be rendered transparently in which case
  a background color is required against which the
  transparent text can be composed. If not provided,
  the background color will be black.

  After rendering the text and composing it against
  the (optional) background, the background can
  be expanded to provide some padding between the
  text and any base image onto which it is later
  composed.  The default no padding.

  ### The Pango markup language

  The text string can take advantage of
  [Pango markup language](https://docs.gtk.org/Pango/pango_markup.html) that
  provides some simple HTML-like text transformation
  capabilities. Note that some of the options to `Image.Text.text/2`,
  such as `:font_weight` and `:letter_spacing` operate by adding markup
  to the provided string.

  ### Arguments

  * `string` is any string. The string will be
    HTML-escaped to avoid malicious code injection. If you
    are completely confident that the text is safe then
    you can pass it by calling with `Phoenix.HTML.raw/1`
    on the string first.

  * `options` is a `t:Keyword.t/0` list of options.

  ### Options

  See also the options for `Image.Text.simple_text/2` which
  is ultimately called by this function.

  * `:font` is any font recognised on the host system.
    The default is "Helvetica". The system command `fc-list`
    can typically be used to see what fonts are available.

  * `:font_size` is an integer font size in pixels. The
    default is `50`.

  * `:font_weight` is one of `:ultralight`, `:light`, `:normal`, `:bold`,
    `:ultrabold`, `:heavy` or an integer between `1` and `1_000`.
    The default is `:normal` which is equivalent to `400`.

  * `:font_file` is a path to any `.ttf` font file. If specfied,
    the `:font` parameter is also required. Note that this option
    is not supported on MacOS systems.

  * `:dpi` sets the resolution of the text generation. The
    default `72` which is suitable for screen output. `300`
    may be more appropriate for printed output.

  * `:text_fill_color` is the fill color of the text.
    The default is "white". If set to `:transparent` then
    the text will be rendered transparently against
    a background. A black background will be forced if a
    `:background_fill_color` is not provided

  * `:background_fill_opacity` is the opacity of the background fill.
    It is a float between `0.0` and `1.0` where `0.0` means transparent
    and `1.0` means opaque. The default is `0.7`.

  * `:padding` is the padding in pixels between the
    text and the edge of the background.  It can be expressed
    as a single integer integer in which case the same padding
    is applied to all four sides of the image.  It can also
    be expressed as a list of two integers like `[0, 0]`.
    The first integer will be used as the padding for the
    left and right of the image. The second integer will be used
    for the top and bottom of the image.  Another alternative is
    to pass a `t:Vimage.t/0` in which case the padding will be derived
    from the image dimensions such that the background covers the
    whole of the image.  The default is `[0, 0]`.

  * `:align` indicates how multiple lines of text are aligned.
    The options are `:left`, `:right` and `:center`. The default
    is `:left`.

  * `:letter_spacing` is the amount of space in pixels between each letter.
    Default is `:normal`.

  * `:background_fill_color` is the background fill color behind
    the text. The default is `:none` which indicates no
    background.

  * `:background_stroke_color` is the colour of the outline
    of the background. The default is "none",

  * `:background_stroke_width` is the integer size in pixels
    of the background border. The default is `1`.

  * `:background_stroke_opacity` is the opacity of the background
    string. It is a float between `0.0` and `1.0` where `0.0` means
    transparent and `1.0` means opaque. The default is `0.7`.

  * `:width` is the maximum width of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options.

  * `:height` is the maximum height of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options. `:height` may only be specified if `:width` is
    also specified.

  * `:x` is the horizontal location of the text on its background.
    The value is either a non-negative integer or one of `:left`,
    `:right` or `:center`. The default is `:center` if `:width` is
    specified and `:left` if it is not.

  * `:y` is the vertical location of the text on its background.
    The value is either a non-negative integer or one of `:top`,
    `:middle` or `:bottom`. The default is `:middle` if `:height`
    is specified and `:top` if it is not.

  ### Returns

  * `{:ok, image}` or

  * `{:error, reason}`

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  * The options `:font_weight` and `:letter_spacing` are implemented by
    wrapping the text in a [Pango markup](https://docs.gtk.org/Pango/pango_markup.html) `span`
    tag. If the `string` parameter starts with `<span` then these two
    options are ignored since this implies the user is taking full control
    of the markup.

  """
  @spec text(Phoenix.HTML.safe() | String.t(), Options.Text.t()) ::
          {:ok, Vimage.t()} | {:error, Image.error_message()}

  def text(string, options \\ []) when is_list(options) do
    with {:ok, options} <- Options.Text.validate_options(options),
         {:ok, text_layer} <- simple_text(string, options),
         {:ok, with_background} <- add_background(text_layer, options),
         {:ok, with_padding} <- add_background_padding(with_background, options) do
      add_background_border(with_padding, options)
    end
  end

  @doc """
  Create a new image from the provided string and
  formatting options returning an image or raising
  an exception.

  `text!/2` creates an image with the
  following steps:

  * Render the text
  * Add an optional background color
  * Expand the background according to the required padding

  The text can be rendered as a positive (the default)
  in which an image of the provided string is rendered
  in the provided font, weight, size, fill color and
  stroke color.

  It can also be rendered transparently in which case
  a background color is required against which the
  transparent text can be composed. If not provided,
  the background color will be black.

  After rendering the text and composing it against
  the (optional) background, the background can
  be expanded to provide some padding between the
  text and any base image onto which it is later
  composed.  The default no padding.

  ### The Pango markup language

  The text string can take advantage of
  [Pango markup language](https://docs.gtk.org/Pango/pango_markup.html) that
  provides some simple HTML-like text transformation
  capabilities. Note that some of the options to `Image.Text.text/2`,
  such as `:font_weight` and `:letter_spacing` operate by adding markup
  to the provided string.

  ### Arguments

  * `string` is any string. The string will be
    HTML-escaped to avoid malicious code injection. If you
    are completely confident that the text is safe then
    you can pass it by calling with `Phoenix.HTML.raw/1`
    on the string first.

  * `options` is a `t:Keyword.t/0` list of options

  ### Options

  See also the options for `Image.Text.simple_text/2` which
  is ultimately called by this function.

  * `:font` is any font name recognised on the host system.
    The default is "Helvetica". The system command `fc-list`
    can typically be used to see what fonts are available.

  * `:font_size` is an integer font size in pixels. The
    default is `50`.

  * `:font_file` is a path to any `.ttf` font file. If specfied,
    the `:font` parameter is also required. Note that this option
    is not supported on MacOS systems.

  * `:font_weight` is one of `:ultralight`, `:light`, `:normal`, `:bold`,
    `:ultrabold`, `:heavy` or an integer between `1` and `1_000`.
    The default is `:normal` which is equivalent to `400`.

  * `:dpi` sets the resolution of the text generation. The
    default `72` which is suitable for screen output. `300`
    may be more appropriate for printed output.

  * `:text_fill_color` is the fill color of the text.
    The default is "white". If set to `:transparent` then
    the text will be rendered transparently against
    a background. A black background will be forced if a
    `:background_fill_color` is not provided.

  * `:background_fill_opacity` is the opacity of the background fill.
    It is a float between `0.0` and `1.0` where `0.0` means transparent
    and `1.0` means opaque. The default is `0.7`.

  * `:padding` is the padding in pixels between the
    text and the edge of the background.  It can be expressed
    as a single integer integer in which case the same padding
    is applied to all four sides of the image.  It can also
    be expressed as a list of two integers like `[0, 0]`.
    The first integer will be used as the padding for the
    left and right of the image. The second integer will be used
    for the top and bottom of the image.  Another alternative is
    to pass a `t:Vimage.t/0` in which case the padding will be derived
    from the image dimensions such that the background covers the
    whole of the image.  The default is `[0, 0]`.

  * `:align` indicates how multiple lines of text are aligned.
    The options are `:left`, `:right` and `:center`. The default
    is `:left`.

  * `:letter_spacing` is the amount of space in pixels between each letter.
    Default is `:normal`.

  * `:background_fill_color` is the background fill color behind
    the text. The default is `:none` which indicates no
    background.

  * `:background_stroke_color` is the colour of the outline
    of the background. The default is "none",

  * `:background_stroke_width` is the integer size in pixels
    of the background border. The default is `1`.

  * `:background_stroke_opacity` is the opacity of the background
    string. It is a float between `0.0` and `1.0` where `0.0` means
    transparent and `1.0` means opaque. The default is `0.7`.

  * `:width` is the maximum width of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options.

  * `:height` is the maximum height of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options. `:height` may only be specified if `:width` is
    also specified.

  * `:x` is the horizontal location of the text on its background.
    The value is either a non-negative integer or one of `:left`,
    `:right` or `:center`. The default is `:center` if `:width` is
    specified and `:left` if it is not.

  * `:y` is the vertical location of the text on its background.
    The value is either a non-negative integer or one of `:top`,
    `:middle` or `:bottom`. The default is `:middle` if `:height`
    is specified and `:top` if it is not.

  ### Returns

  * `image` or

  * raises an exception.

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  * The options `:font_weight` and `:letter_spacing` are implemented by
    wrapping the text in a [Pango markup](https://docs.gtk.org/Pango/pango_markup.html) `span`
    tag. If the `string` parameter starts with `<span` then these two
    options are ignored since this implies the user is taking full control
    of the markup.

  """
  @spec text!(String.t(), Keyword.t()) :: Vimage.t() | no_return()
  def text!(string, options \\ []) do
    case text(string, options) do
      {:ok, image} -> image
      {:error, reason} -> raise Image.Error, reason
    end
  end

  @doc """
  Creates an image from the provided text.

  This function creates an image from the text
  but does not apply a background or padding.

  ### Arguments

  * `string` is any string. The string will be
    HTML-escaped to avoid malicious code injection. If you
    are completely confident that the text is safe then
    you can pass it by calling with `Phoenix.HTML.raw/1`
    on the string first.

  * `options` is a `t:Keyword.t/0` list of options.

  ### Options

  * `:text_fill_color` is the fill color of the text.
    The default is "white". If set to `:transparent` then
    the text will be rendered transparently against
    a background.

  * `:width` is the maximum width of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options.

  * `:height` is the maximum height of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options.

  * `:justify` is a boolean indicating whether to justify text.
    The default is `false`.

  * `:letter_spacing` is the amount of space in pixels between each letter.
    Default is `:normal`.

  * `:font` is any font recognised on the host system.
    The default is "Helvetica". The system command `fc-list`
    can typically be used to see what fonts are available.

  * `:font_weight` is one of `:ultralight`, `:light`, `:normal`, `:bold`,
    `:ultrabold`, `:heavy` or an integer between `1` and `1_000`.
    The default is `:normal` which is equivalent to `400`.

  * `:font_size` is an integer font size in pixels. The
    default is `50`. If set to `0`, the font size will
    be calculated to fit the text within the specified `:width`
    and `:height`.

  * `:dpi` sets the resolution of the text generation. The
    default `72` which is suitable for screen output. `300`
    may be more appropriate for printed output.

  ### Returns

  * `{:ok, image}` or

  * `{:error, reason}`.

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec simple_text(String.t(), Keyword.t()) :: {:ok, Vimage.t()} | {:error, Image.error_message()}
  def simple_text(string, options \\ [])

  def simple_text(string, options) when is_list(options) do
    with {:ok, options} <- Options.Text.validate_options(options) do
      simple_text(string, options)
    end
  end

  def simple_text(string, %{} = options) do
    with {:ok, string} <- escape_html_text(string) do
      {:ok, text_layer} = render_text(string, options)

      if transparent_text?(options) do
        Image.convert_alpha_to_mask(text_layer)
      else
        {:ok, text_layer}
      end
    end
  end

  @doc """
  Creates an image from the provided text and
  returns an image or raises an exception.

  This function creates an image from the text
  but does not apply a background or padding.

  ### Arguments

  * `string` is any string. The string will be
    HTML-escaped to avoid malicious code injection. If you
    are completely confident that the text is safe then
    you can pass it by calling with `Phoenix.HTML.raw/1`
    on the string first.

  * `options` is a `t:Keyword.t/0` list of options.

  ### Options

  * `:text_fill_color` is the fill color of the text.
    The default is "white". If set to `:transparent` then
    the text will be rendered transparently against
    a background.

  * `:width` is the maximum width of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options.

  * `:height` is the maximum height of the generated text image in pixels. The
    default is calculated by the rendering engine based upon the font
    and other options.

  * `:justify` is a boolean indicating whether to justify text.
    The default is `false`.

  * `:letter_spacing` is the amount of space in pixels between each letter.
    Default is `:normal`.

  * `:font` is any font recognised on the host system.
    The default is "Helvetica". The system command `fc-list`
    can typically be used to see what fonts are available.

  * `:font_weight` is one of `:ultralight`, `:light`, `:normal`, `:bold`,
    `:ultrabold`, `:heavy` or an integer between `1` and `1_000`.
    The default is `:normal` which is equivalent to `400`.

  * `:font_size` is an integer font size in pixels. The
    default is `50`. If set to `0`, the font size will
    be calculated to fit the text within the specified `:width`
    and `:height`.

  * `:dpi` sets the resolution of the text generation. The
    default `72` which is suitable for screen output. `300`
    may be more appropriate for printed output.

  ### Returns

  * `image` or

  * raises an exception.

  ### Notes

  * There is no text wrapping, justification or kerning
    applied. This means this function is not a general
    purpose text layout function and is suitable mostly
    for overlaying text for emphasis over another image.

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec simple_text!(String.t(), Keyword.t()) :: Vimage.t() | no_return()
  def simple_text!(string, options \\ []) do
    case simple_text(string, options) do
      {:ok, image} -> image
      {:error, reason} -> raise Image.Error, reason
    end
  end

  @doc """
  Adds a background to an image generated from
  text.

  ### Arguments

  * `image` is any `t:Vimage.t/0` but is expected
    to be an image generated by `Image.Text.text/2`.

  * `options` is a `t:Keyword.t/0` list of options.

  ### Options

  * `:background_fill_color` is the background fill color behind
    the text. The default is `:none` which indicates no
    background. Note that if

  * `:background_fill_opacity` is the opacity of the background. It is a
    float between `0.0` and `1.0` where `0.0` means transparent
    and `1.0` means opaque. The default is `0.7`.

  ### Returns

  * `{:ok, image}` or

  * `{:error, reason}`

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec add_background(Vimage.t(), Keyword.t()) ::
          {:ok, Vimage.t()} | {:error, Image.error_message()}
  def add_background(image, options \\ [])

  def add_background(%Vimage{} = image, options) when is_list(options) do
    with {:ok, options} <- Options.Text.validate_options(options) do
      add_background(image, options)
    end
  end

  def add_background(%Vimage{} = image, %{background_fill_color: :none} = _options) do
    {:ok, image}
  end

  def add_background(%Vimage{} = image, %{} = options) do
    {:ok, background} = render_background(image, options)

    # If its transparent text then the image
    # is a mask and we add it as the alpha channel
    # otherwise just composite the two images

    if transparent_text?(options) do
      {:ok, image} = Operation.bandjoin([background, image])
      {:ok, apply_opacity(image, options)}
    else
      Operation.composite2(background, image, :VIPS_BLEND_MODE_OVER)
    end
  end

  @doc """
  Adds a background to an image generated from
  text returning an image or raising an exception.

  ### Arguments

  * `image` is any `t:Vimage.t/0` but is expected
    to be an image generated by `Image.Text.text/2`.

  * `options` is a `t:Keyword.t/0` list of options.

  ### Options

  * `:background_fill_color` is the background fill color behind
    the text. The default is `:none` which indicates no
    background.

  * `:background_fill_opacity` is the opacity of the background. It is a
    float between `0.0` and `1.0` where `0.0` means transparent
    and `1.0` means opaque. The default is `0.7`.

  ### Returns

  * `image` or

  * raises an exception

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec add_background!(Vimage.t(), Keyword.t()) :: Vimage.t() | no_return()
  def add_background!(image, options \\ []) do
    case add_background(image, options) do
      {:ok, image} -> image
      {:error, reason} -> raise Image.Error, reason
    end
  end

  @doc """
  Adds padding to a background to an image generated from
  text.

  ### Arguments

  * `image` is any `t:Vimage.t/0` but is expected
    to be an image generated by `Image.Text.add_background/2`.

  * `options` is a `t:Keyword.t/0` list of options.

  ### Options

  * `:background_fill_color` is the background fill color behind
    the text. The default is `:none` which indicates no
    background.

  * `:background_fill_opacity` is the opacity of the background. It is a
    float between `0.0` and `1.0` where `0.0` means transparent
    and `1.0` means opaque. The default is `0.7`.

  * `:padding` is the padding in pixels between the
    text and the edge of the background.  It can be expressed
    as a single integer integer in which case the same padding
    is applied to all four sides of the image.  It can also
    be expressed as a list of two integers like `[0, 0]`.
    The first integer will be used as the padding for the
    left and right of the image. The second integer will be used
    for the top and bottom of the image.  Another alternative is
    to pass a `t:Vimage.t/0` in which case the padding will be derived
    from the image dimensions such that the background covers the
    whole of the image.  The default is `[0, 0]`.

  ### Returns

  * `{:ok, image}` or

  * `{:error, reason}`

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec add_background_padding(Vimage.t(), Keyword.t()) ::
          {:ok, Vimage.t()} | {:error, Image.error_message()}

  def add_background_padding(image, options \\ [])

  def add_background_padding(%Vimage{} = image, options) when is_list(options) do
    with {:ok, options} <- Options.Text.validate_options(options) do
      add_background_padding(image, options)
    end
  end

  def add_background_padding(%Vimage{} = image, %{} = options) do
    [padding_left, padding_top] = padding_from_options(image, options.padding)

    options =
      options
      |> Map.put_new(:background_width, Image.width(image) + padding_left * 2)
      |> Map.put_new(:background_height, Image.height(image) + padding_top * 2)

    width = Map.get(options, :background_width)
    height = Map.get(options, :background_height)
    opacity = Map.get(options, :background_fill_opacity)

    background_fill_color =
      options
      |> Map.get(:background_fill_color)
      |> Image.Color.rgba_color!(opacity)

    image =
      if Image.has_alpha?(image), do: image, else: Image.add_alpha!(image, :transparent)

    Operation.embed(image, padding_left, padding_top, width, height,
      background: background_fill_color
    )
  end

  @doc """
  Adds padding to a background to an image generated from
  text returning an image or raising an exception.

  ### Arguments

  * `image` is any `t:Vimage.t/0` but is expected
    to be an image generated by `Image.Text.add_background/2`.

  * `options` is a `t:Keyword.t/0` list of options.

  ### Options

  * `:background_fill_color` is the background fill color behind
    the text. The default is `:none` which indicates no
    background.

  * `:background_fill_opacity` is the opacity of the background. It is a
    float between `0.0` and `1.0` where `0.0` means transparent
    and `1.0` means opaque. The default is `0.7`.

  * `:padding` is the padding in pixels between the
    text and the edge of the background.  It can be expressed
    as a single integer integer in which case the same padding
    is applied to all four sides of the image.  It can also
    be expressed as a list of two integers like `[0, 0]`.
    The first integer will be used as the padding for the
    left and right of the image. The second integer will be used
    for the top and bottom of the image.  Another alternative is
    to pass a `t:Vimage.t/0` in which case the padding will be derived
    from the image dimensions such that the background covers the
    whole of the image.  The default is `[0, 0]`.

  ### Returns

  * `image` or

  * raises an exception

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec add_background_padding!(Vimage.t(), Keyword.t()) :: Vimage.t() | no_return()
  def add_background_padding!(image, options \\ []) do
    case add_background_padding(image, options) do
      {:ok, image} -> image
      {:error, reason} -> raise Image.Error, reason
    end
  end

  defp padding_from_options(image, %Vimage{} = base_image) do
    padding_left = div(Image.width(base_image) - Image.width(image), 2)
    padding_top = div(Image.height(base_image) - Image.height(image), 2)
    [padding_left, padding_top]
  end

  defp padding_from_options(_image, [_padding_left, _padding_top] = padding) do
    padding
  end

  @doc """
  Adds a border on an image, typically an
  image generated from a string.

  ### Arguments

  * `image` is any `t:Vimage.t/0`

  * `options` is a `t:Keyword.t/0` list of options

  ### Options

  * `:background_stroke_color` is the colour of the outline
    of the background. The default is ":none",

  * `:background_stroke_width` is the integer size in pixels
    of the background border. The default is `1`.

  * `:background_stroke_opacity` is the opacity of the background
    string. It is a float between `0.0` and `1.0` where `0.0` means
    transparent and `1.0` means opaque. The default is `0.7`.

  ### Returns

  * `{:ok, image}` or

  * `{:error, reason}`

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec add_background_border(Vimage.t(), Keyword.t()) ::
          {:ok, Vimage.t()} | {:error, Image.error_message()}
  def add_background_border(image, options \\ [])

  def add_background_border(%Vimage{} = image, options) when is_list(options) do
    with {:ok, options} <- Options.Text.validate_options(options) do
      add_background_border(image, options)
    end
  end

  def add_background_border(image, %{background_stroke_color: :none} = _options) do
    {:ok, image}
  end

  def add_background_border(image, %{padding: 0} = _options) do
    {:ok, image}
  end

  def add_background_border(image, %{} = options) do
    with {:ok, {border, _flags}} <- render_background_border(image, options) do
      Operation.composite2(image, border, :VIPS_BLEND_MODE_OVER)
    end
  end

  @doc """
  Adds a border on an image, typically an
  image generated from a string. Returns an
  image or raises an exception.

  ### Arguments

  * `image` is any `t:Vimage.t/0`

  * `options` is a `t:Keyword.t/0` list of options

  ### Options

  * `:background_stroke_color` is the colour of the outline
    of the background. The default is "none",

  * `:background_stroke_width` is the integer size in pixels
    of the background border. The default is `1`.

  * `:background_stroke_opacity` is the opacity of the background
    string. It is a float between `0.0` and `1.0` where `0.0` means
    transparent and `1.0` means opaque. The default is `0.7`.

  ### Returns

  * `image` or

  * raises an exception

  ### Notes

  * Colors may be any valid
    [CSS color name](https://www.w3.org/wiki/CSS/Properties/color/keywords) or
    a six hexadecimal digit string prefixed with `#`. For example
    `#FF00FF` for the color "Fuchsia".

  """
  @spec add_background_border!(Vimage.t(), Keyword.t()) :: Vimage.t() | no_return()
  def add_background_border!(image, options \\ []) do
    case add_background_border(image, options) do
      {:ok, image} -> image
      {:error, reason} -> raise Image.Error, reason
    end
  end

  # For transparent text we need to render the text in
  # white which is then converted later to a transparency
  # mask
  @dialyzer {:nowarn_function, {:render_text, 2}}

  defp render_text(text, %{text_fill_color: :transparent} = options) do
    render_text(text, Map.put(options, :text_fill_color, :white))
  end

  defp render_text(text, options) do
    font = options.font <> font_size(options)
    height = options[:height]
    width = options[:width]

    text_options =
      [
        font: font,
        align: options.align,
        justify: options.justify
      ]
      |> maybe_add_height(height)
      |> maybe_add_width(width)
      |> maybe_add_dpi(options[:dpi])
      |> Image.maybe_add_fontfile(options[:fontfile])

    with {:ok, text} <- maybe_add_pango_span(text, options),
         {:ok, {text_mask, _}} <- Operation.text(text, text_options),
         {:ok, color_layer} <- Image.new(text_mask, color: options.text_fill_color),
         {:ok, joined} <- Operation.bandjoin([color_layer, text_mask]),
         {:ok, {x, y}} <- location_from_options(joined, options.x, options.y, width, height) do
      if width && height do
        Operation.embed(joined, x, y, width, height)
      else
        {:ok, joined}
      end
    end
  end

  defp font_size(options) do
    if options.font_size > 0, do: " #{inspect(options.font_size)}", else: ""
  end

  defp maybe_add_height(options, nil), do: options
  defp maybe_add_height(options, height), do: Keyword.put(options, :height, height)

  defp maybe_add_width(options, nil), do: options
  defp maybe_add_width(options, width), do: Keyword.put(options, :width, width)

  defp maybe_add_dpi(options, nil), do: options
  defp maybe_add_dpi(options, dpi), do: Keyword.put(options, :dpi, dpi)

  @span_params [:letter_spacing, :font_weight]

  # If the text starts with a span then we assume the user is
  # determining the text format
  defp maybe_add_pango_span("<span" <> _rest = text, _options) do
    {:ok, text}
  end

  defp maybe_add_pango_span(text, options) do
    span_params =
      @span_params
      |> Enum.map(&span_param(&1, options[&1]))
      |> Enum.reject(&is_nil/1)
      |> Enum.join(" ")

    if span_params == "" do
      {:ok, text}
    else
      {:ok, "<span #{span_params}>#{text}</span>"}
    end
  end

  defp span_param(:letter_spacing, letter_spacing) when is_integer(letter_spacing) do
    "letter_spacing='#{round(letter_spacing * 1024)}'"
  end

  defp span_param(:font_weight, :normal) do
    nil
  end

  defp span_param(:font_weight, font_weight)
       when is_atom(font_weight) or is_integer(font_weight) do
    "font_weight='#{font_weight}'"
  end

  defp span_param(_, _) do
    nil
  end

  defp location_from_options(image, :left, y, width, height) do
    location_from_options(image, 0, y, width, height)
  end

  defp location_from_options(image, :center, y, width, height) when is_integer(width) do
    x = div(width - Image.width(image), 2)
    location_from_options(image, x, y, width, height)
  end

  defp location_from_options(image, :right, y, width, height) when is_integer(width) do
    x = width - Image.width(image)
    location_from_options(image, x, y, width, height)
  end

  defp location_from_options(image, x, :top, width, height) do
    location_from_options(image, x, 0, width, height)
  end

  defp location_from_options(image, x, :middle, width, height) when is_integer(height) do
    y = div(height - Image.height(image), 2)
    location_from_options(image, x, y, width, height)
  end

  defp location_from_options(image, x, :bottom, width, height) when is_integer(height) do
    y = height - Image.height(image)
    location_from_options(image, x, y, width, height)
  end

  defp location_from_options(_image, _x, _y, nil, nil) do
    {:ok, {0, 0}}
  end

  defp location_from_options(_image, x_location, _y, nil, _height)
       when x_location in [:center, :right] do
    {:error, ":center and :right cannot be specified unless :width is also specified"}
  end

  defp location_from_options(_image, _x, y_location, _width, nil)
       when y_location in [:middle, :bottom] do
    {:error, ":middle and :bottom cannot be specified unless :height is also specified"}
  end

  defp location_from_options(image, x, y, width, nil) when is_integer(width) do
    if Image.width(image) + x <= width do
      {:ok, {x, y}}
    else
      {:error,
       "Location [#{inspect(x)}, _] would place the text " <>
         "outside the image bounds specified"}
    end
  end

  defp location_from_options(image, x, y, nil, height) when is_integer(height) do
    if Image.height(image) + y <= height do
      {:ok, {x, y}}
    else
      {:error,
       "Location [_, #{inspect(y)}] would place the text " <>
         "outside the image bounds specified"}
    end
  end

  defp location_from_options(image, x, y, width, height)
       when is_integer(width) and is_integer(height) do
    if Image.width(image) + x <= width && Image.height(image) + y <= height do
      {:ok, {x, y}}
    else
      {:error,
       "Location [#{inspect(x)}, #{inspect(y)}] would place the text " <>
         "outside the image bounds specified"}
    end
  end

  # Render a background rectangle and return
  # it without its alpha channel since we will
  # apply transparency from the text image

  # Don't apply a background stroke since
  # we want the stroke around the padded area.

  defp render_background(image, %{} = options) do
    width = Map.get(options, :background_width, Image.width(image))
    height = Map.get(options, :background_height, Image.height(image))

    svg = """
    <svg width="#{width}px" height="#{height}px">
      <rect
        fill="#{options.background_fill_color}"
        opacity="#{options.background_fill_opacity}"
        width="100%"
        height="100%"
      />
    </svg>
    """

    {:ok, {rectangle, _flags}} = Operation.svgload_buffer(svg)

    if transparent_text?(options) do
      Operation.extract_band(rectangle, 0, n: 3)
    else
      {:ok, rectangle}
    end
  end

  # Render a background border. The fill will be
  # transparent so the border cam be composed over
  # another layer.

  defp render_background_border(image, %{} = options) do
    width = Map.get(options, :background_width, Image.width(image))
    height = Map.get(options, :background_height, Image.height(image))

    # This because the stroke is along the centre line and therefore
    # 50% of it is clipped outside the background. We are after the
    # equivalent of the stroke inside the bounding box.

    stroke_width = options.background_stroke_width * 2

    svg = """
    <svg width="#{width}px" height="#{height}px">
      <rect
        fill="transparent"
        stroke="#{options.background_stroke_color}"
        stroke-width="#{stroke_width}"
        opacity="#{options.background_stroke_opacity}"
        width="100%"
        height="100%"
      />
    </svg>
    """

    Operation.svgload_buffer(svg)
  end

  defp apply_opacity(image, options) do
    use Image.Math

    image * [1.0, 1.0, 1.0, options.background_fill_opacity]
  end

  defp transparent_text?(%{} = options) do
    Map.get(options, :text_fill_color) in [:transparent, nil]
  end

  defp escape_html_text({:safe, string}) do
    {:ok, string}
  end

  defp escape_html_text(string) do
    string =
      string
      |> Phoenix.HTML.html_escape()
      |> Phoenix.HTML.safe_to_string()

    {:ok, string}
  end
end
