defmodule Expression.Callbacks do
  @moduledoc """
  The function callbacks for the standard function set available
  in FLOIP expressions.

  This should be relatively swappable with another implementation.
  The only requirement is the `handle/3` function.

  FLOIP functions are case insensitive. All functions in this callback
  module are implemented as lowercase names.

  Some functions accept a variable amount of arguments. Elixir doesn't
  support variable arguments in functions.

  If a function accepts a variable number of arguments the convention
  is to call the `<function_name>_vargs/2` callback where the context
  is given as the first argument and the argument list as a second
  argument.

  Reserved names such as `and`, `if`, and `or` are suffixed with an
  underscore.
  """

  @reserved_words ~w[and if or]

  @punctuation_pattern ~r/\s*[,:;!?.-]\s*|\s/

  @doc """
  Convert a string function name into an atom meant to handle
  that function

  Reserved words such as `and`, `if`, and `or` are automatically suffixed
  with an `_` underscore.
  """
  def atom_function_name(function_name) when function_name in @reserved_words,
    do: atom_function_name("#{function_name}_")

  def atom_function_name(function_name) do
    String.to_atom(function_name)
  end

  @doc """
  Handle a function call while evaluating the AST.

  Handlers in this module are either:

  1. The function name as is
  2. The function name with an underscore suffix if the function name is a reserved word
  3. The function name suffixed with `_vargs` if the takes a variable set of arguments
  """
  @spec handle(function_name :: binary, arguments :: [any], context :: map) ::
          {:ok, any} | {:error, :not_implemented}
  def handle(function_name, arguments, context) do
    exact_function_name = atom_function_name(function_name)
    vargs_function_name = atom_function_name("#{function_name}_vargs")

    cond do
      # Check if the exact function signature has been implemented
      function_exported?(__MODULE__, exact_function_name, length(arguments) + 1) ->
        {:ok, apply(__MODULE__, exact_function_name, [context] ++ arguments)}

      # Check if it's been implemented to accept a variable amount of arguments
      function_exported?(__MODULE__, vargs_function_name, 2) ->
        {:ok, apply(__MODULE__, vargs_function_name, [context, arguments])}

      # Otherwise fail
      true ->
        {:error, "#{function_name} is not implemented."}
    end
  end

  @doc """
  Defines a new date value

  ```
  This is a date @DATE(2012, 12, 25)
  ```

  # Example

      iex> to_string(Expression.Callbacks.date(%{}, 2012, 12, 25))
      "2012-12-25 00:00:00Z"

  """
  def date(_ctx, year, month, day) do
    fields = [
      calendar: Calendar.ISO,
      year: year,
      month: month,
      day: day,
      hour: 0,
      minute: 0,
      second: 0,
      time_zone: "Etc/UTC",
      zone_abbr: "UTC",
      utc_offset: 0,
      std_offset: 0
    ]

    struct(DateTime, fields)
  end

  @doc """
  Converts date stored in text to an actual date,
  using `strftime` formatting.

  It will fallback to "%Y-%m-%d %H:%M:%S" if no formatting is supplied

  ```
  You joined on @DATEVALUE(contact.joined_date, "%Y-%m%-d")
  ```

  # Example

      iex> date = Expression.Callbacks.date(%{}, 2020, 12, 20)
      iex> Expression.Callbacks.datevalue(%{}, date)
      "2020-12-20 00:00:00"
      iex> Expression.Callbacks.datevalue(%{}, date, "%Y-%m-%d")
      "2020-12-20"
  """
  def datevalue(ctx, date, format \\ "%Y-%m-%d %H:%M:%S")

  def datevalue(_ctx, date, format) do
    Timex.format!(date, format, :strftime)
  end

  @doc """
  Returns only the day of the month of a date (1 to 31)

  ```
  The current day is @DAY(contact.joined_date)
  ```

  # Example

      iex> now = DateTime.utc_now()
      iex> day = Expression.Callbacks.day(%{}, now)
      iex> day == now.day
      true
  """
  def day(_ctx, %{day: day} = _date) do
    day
  end

  @doc """
  Moves a date by the given number of months

  ```
  Next month's meeting will be on @EDATE(date.today, 1)
  ```

  # Example

      iex> now = DateTime.utc_now()
      iex> future = Timex.shift(now, months: 1)
      iex> date = Expression.Callbacks.edate(%{}, now, 1)
      iex> future == date
      true
  """
  def edate(_ctx, date, months) do
    date |> Timex.shift(months: months)
  end

  @doc """
  Returns only the hour of a datetime (0 to 23)

  ```
  The current hour is @HOUR(NOW())
  ```

  # Example

      iex> now = DateTime.utc_now()
      iex> hour = Expression.Callbacks.hour(%{}, now)
      iex> now.hour == hour
      true
  """
  def hour(_ctx, %{hour: hour} = _date) do
    hour
  end

  @doc """
  Returns only the minute of a datetime (0 to 59)

  ```
  The current minute is @MINUTE(NOW())
  ```

  # Example

      iex> now = DateTime.utc_now()
      iex> minute = Expression.Callbacks.minute(%{}, now)
      iex> now.minute == minute
      true
  """
  def minute(_ctx, %{minute: minute} = _date) do
    minute
  end

  @doc """
  Returns only the month of a date (1 to 12)

  ```
  The current month is @MONTH(NOW())
  ```

  # Example

      iex> now = DateTime.utc_now()
      iex> month = Expression.Callbacks.month(%{}, now)
      iex> now.month == month
      true
  """
  def month(_ctx, %{month: month} = _date) do
    month
  end

  @doc """
  Returns the current date time as UTC

  ```
  It is currently @NOW()
  ```

  # Example

    iex> DateTime.utc_now() == Expression.Callbacks.now(%{})
  """
  def now(_ctx) do
    DateTime.utc_now()
  end

  @doc """
  Returns only the second of a datetime (0 to 59)

  ```
  The current second is @SECOND(NOW())
  ```

  # Example

      iex> now = DateTime.utc_now()
      iex> second = Expression.Callbacks.second(%{}, now)
      iex> now.second == second
      true

  """
  def second(_ctx, %{second: second} = _date) do
    second
  end

  @doc """
  Defines a time value which can be used for time arithmetic

  ```
  2 hours and 30 minutes from now is @(date.now + TIME(2, 30, 0))
  ```

  # Example

      iex> Expression.Callbacks.time(%{}, 12, 13, 14)
      %Time{hour: 12, minute: 13, second: 14}

  """
  def time(_ctx, hours, minutes, seconds) do
    %Time{hour: hours, minute: minutes, second: seconds}
  end

  @doc """
  Converts time stored in text to an actual time

  ```
  Your appointment is at @(date.today + TIME("2:30"))
  ```

  # Example

      iex> Expression.Callbacks.timevalue(%{}, "2:30")
      %Time{hour: 2, minute: 30, second: 0}

      iex> Expression.Callbacks.timevalue(%{}, "2:30:55")
      %Time{hour: 2, minute: 30, second: 55}
  """
  def timevalue(_ctx, expression) do
    parts =
      expression
      |> String.split(":")
      |> Enum.map(&String.to_integer/1)

    defaults = [
      hour: 0,
      minute: 0,
      second: 0
    ]

    fields =
      [:hour, :minute, :second]
      |> Enum.zip(parts)

    struct(Time, Keyword.merge(defaults, fields))
  end

  @doc """
  Returns the current date

  ```
  Today's date is @TODAY()
  ```

  # Example

      iex> today = Date.utc_today()
      iex> today == Expression.Callbacks.today(%{})
      true

  """
  def today(_ctx) do
    Date.utc_today()
  end

  @doc """
  Returns the day of the week of a date (1 for Sunday to 7 for Saturday)

  ```
  Today is day no. @WEEKDAY(TODAY()) in the week
  ```

  # Example

      iex> today = DateTime.utc_now()
      iex> expected = Timex.weekday(today)
      iex> weekday = Expression.Callbacks.weekday(%{}, today)
      iex> weekday == expected
      true
  """
  def weekday(_ctx, date) do
    Timex.weekday(date)
  end

  @doc """
  Returns only the year of a date

  ```
  The current year is @YEAR(NOW())
  ```

  # Example

      iex> %{year: year} = now = DateTime.utc_now()
      iex> year == Expression.Callbacks.year(%{}, now)

  """
  def year(_ctx, %{year: year} = _date) do
    year
  end

  @doc """
  Returns TRUE if and only if all its arguments evaluate to TRUE

  ```
  @AND(contact.gender = "F", contact.age >= 18)
  ```

  # Example

      iex> Expression.Callbacks.handle("and", [true, true], %{})
      {:ok, true}
      iex> Expression.Callbacks.and_vargs(%{}, [true, true])
      true
      iex> Expression.Callbacks.and_vargs(%{}, [true, false])
      false
      iex> Expression.Callbacks.and_vargs(%{}, [false, false])
      false

  """
  def and_vargs(_ctx, arguments) do
    Enum.all?(arguments, fn
      true -> true
      _other -> false
    end)
  end

  @doc """
  Returns one value if the condition evaluates to TRUE, and another value if it evaluates to FALSE

  ```
  Dear @IF(contact.gender = "M", "Sir", "Madam")
  ```

  # Example

      iex> Expression.Callbacks.handle("if", [true, "Yes", "No"], %{})
      {:ok, "Yes"}
      iex> Expression.Callbacks.handle("if", [false, "Yes", "No"], %{})
      {:ok, "No"}
  """
  def if_(_ctx, condition, yes, no) do
    if(condition, do: yes, else: no)
  end

  @doc """
  Returns TRUE if any argument is TRUE

  ```
  @OR(contact.state = "GA", contact.state = "WA", contact.state = "IN")
  ```

  # Example

      iex> Expression.Callbacks.handle("or", [true, false], %{})
      {:ok, true}
      iex> Expression.Callbacks.handle("or", [true, true], %{})
      {:ok, true}
      iex> Expression.Callbacks.handle("or", [false, false], %{})
      {:ok, false}
  """
  def or_vargs(_ctx, arguments) do
    Enum.any?(arguments, fn
      true -> true
      _anything_else -> false
    end)
  end

  @doc """
  Returns the absolute value of a number

  ```
  The absolute value of -1 is @ABS(-1)
  ```

  # Example

      iex> Expression.Callbacks.abs(%{}, -1)
      1
  """
  def abs(_ctx, number) do
    abs(number)
  end

  @doc """
  Returns the maximum value of all arguments

  ```
  Please complete at most @MAX(flow.questions, 10) questions
  ```

  # Example

      iex> Expression.Callbacks.handle("max", [1, 2, 3], %{})
      {:ok, 3}
  """
  def max_vargs(_ctx, arguments) do
    Enum.max(arguments)
  end

  @doc """
  Returns the minimum value of all arguments

  ```
  Please complete at least @MIN(flow.questions, 10) questions
  ```

  #  Example

      iex> Expression.Callbacks.handle("min", [1, 2, 3], %{})
      {:ok, 1}
  """
  def min_vargs(_ctx, arguments) do
    Enum.min(arguments)
  end

  @doc """
  Returns the result of a number raised to a power - equivalent to the ^ operator

  ```
  2 to the power of 3 is @POWER(2, 3)
  ```
  """
  def power(_ctx, a, b) do
    :math.pow(a, b)
  end

  @doc """
  Returns the sum of all arguments, equivalent to the + operator

  ```
  You have @SUM(contact.reports, contact.forms) reports and forms
  ```

  # Example

      iex> Expression.Callbacks.handle("sum", [1, 2, 3], %{})
      {:ok, 6}

  """
  def sum_vargs(_ctx, arguments) do
    Enum.sum(arguments)
  end

  @doc """
  Returns the character specified by a number

  ```
  As easy as @CHAR(65), @CHAR(66), @CHAR(67)
  ```

  # Example

      iex> Expression.Callbacks.char(%{}, 65)
      "A"

  """
  def char(_ctx, code) do
    <<code>>
  end

  @doc """
  Removes all non-printable characters from a text string

  ```
  You entered @CLEAN(step.value)
  ```

  # Example

      iex> Expression.Callbacks.clean(%{}, <<65, 0, 66, 0, 67>>)
      "ABC"
  """
  def clean(_ctx, binary) do
    binary
    |> String.graphemes()
    |> Enum.filter(&String.printable?/1)
    |> Enum.join("")
  end

  @doc """
  Returns a numeric code for the first character in a text string

  ```
  The numeric code of A is @CODE("A")
  ```

  # Example

      iex> Expression.Callbacks.code(%{}, "A")
      65
  """
  def code(_ctx, <<code>>) do
    code
  end

  @doc """
  Joins text strings into one text string

  ```
  Your name is @CONCATENATE(contact.first_name, " ", contact.last_name)
  ```

  # Example

      iex> Expression.Callbacks.handle("concatenate", ["name", " ", "surname"], %{})
      {:ok, "name surname"}
  """
  def concatenate_vargs(_ctx, arguments) do
    Enum.join(arguments, "")
  end

  @doc """
  Formats the given number in decimal format using a period and commas

  ```
  You have @FIXED(contact.balance, 2) in your account
  ```

  # Example

      iex> Expression.Callbacks.fixed(%{}, 4.209922, 2, false)
      "4.21"
      iex> Expression.Callbacks.fixed(%{}, 4000.424242, 4, true)
      "4,000.4242"
      iex> Expression.Callbacks.fixed(%{}, 3.7979, 2, false)
      "3.80"
      iex> Expression.Callbacks.fixed(%{}, 3.7979, 2)
      "3.80"

  """
  def fixed(_ctx, number, precision, no_commas \\ false)

  def fixed(_ctx, number, precision, true) do
    Number.Delimit.number_to_delimited(number,
      precision: precision,
      delimiter: ",",
      separator: "."
    )
  end

  def fixed(_ctx, number, precision, false) do
    Number.Delimit.number_to_delimited(number, precision: precision)
  end

  @doc """
  Returns the first characters in a text string

  ```
  You entered PIN @LEFT(step.value, 4)
  ```

  # Example

      iex> Expression.Callbacks.left(%{}, "foobar", 4)
      "foob"
  """
  def left(_ctx, binary, size) do
    binary_part(binary, 0, size)
  end

  @doc """
  Returns the number of characters in a text string

  ```
  You entered @LEN(step.value) characters
  ```

  # Example

      iex> Expression.Callbacks.len(%{}, "foo")
      3
      iex> Expression.Callbacks.len(%{}, "zoë")
      3
  """
  def len(_ctx, binary) do
    String.length(binary)
  end

  @doc """
  Converts a text string to lowercase

  ````
  Welcome @LOWER(contact)
  ```

  # Example

      iex> Expression.Callbacks.lower(%{}, "Foo Bar")
      "foo bar"

  """
  def lower(_ctx, binary) do
    String.downcase(binary)
  end

  @doc """
  Capitalizes the first letter of every word in a text string

  ```
  Your name is @PROPER(contact)
  ```

  # Example

      iex> Expression.Callbacks.proper(%{}, "foo bar")
      "Foo Bar"
  """
  def proper(_ctx, binary) do
    binary
    |> String.split(" ")
    |> Enum.map(&String.capitalize/1)
    |> Enum.join(" ")
  end

  @doc """
  Repeats text a given number of times

  ```
  Stars! @REPT("*", 10)
  ```

  # Example

      iex> Expression.Callbacks.rept(%{}, "*", 10)
      "**********"
  """
  def rept(_ctx, value, amount) do
    String.duplicate(value, amount)
  end

  @doc """
  Returns the last characters in a text string

  ```
  Your input ended with ...@RIGHT(step.value, 3)
  ```

  # Example

      iex> Expression.Callbacks.right(%{}, "testing", 3)
      "ing"

  """
  def right(_ctx, binary, size) do
    String.slice(binary, -size, size)
  end

  @doc """
  Substitutes new_text for old_text in a text string. If instance_num is given, then only that instance will be substituted

  ```
  @SUBSTITUTE(step.value, "can't", "can")
  ```

  # Example

    iex> Expression.Callbacks.substitute(%{}, "I can't", "can't", "can do")
    "I can do"

  """
  def substitute(%{}, subject, pattern, replacement) do
    String.replace(subject, pattern, replacement)
  end

  @doc """
  Returns the unicode character specified by a number

  ```
  As easy as @UNICHAR(65), @UNICHAR(66) , @UNICHAR(67)
  ```

  # Example

    iex> Expression.Callbacks.unichar(%{}, 65)
    "A"
    iex> Expression.Callbacks.unichar(%{}, 233)
    "é"

  """
  def unichar(_ctx, code) do
    <<code::utf8>>
  end

  @doc """
  Returns a numeric code for the first character in a text string

  ```
  The numeric code of A is @UNICODE("A")
  ```

  # Example

      iex> Expression.Callbacks.unicode(%{}, "A")
      65
      iex> Expression.Callbacks.unicode(%{}, "é")
      233
  """
  def unicode(_ctx, <<code::utf8>>) do
    code
  end

  @doc """
  Converts a text string to uppercase

  ```
  WELCOME @UPPER(contact)!!
  ```

  # Example

      iex> Expression.Callbacks.upper(%{}, "foo")
      "FOO"
  """
  def upper(_ctx, binary) do
    String.upcase(binary)
  end

  @doc """
  Returns the first word in the given text - equivalent to WORD(text, 1)

  ```
  The first word you entered was @FIRST_WORD(step.value)
  ```

  # Example

      iex> Expression.Callbacks.first_word(%{}, "foo bar baz")
      "foo"

  """
  def first_word(_ctx, binary) do
    [word | _] = String.split(binary, " ")
    word
  end

  @doc """
  Formats a number as a percentage

  ```
  You've completed @PERCENT(contact.reports_done / 10) reports
  ```

  # Example

      iex> Expression.Callbacks.percent(%{}, 2/10)
      "20%"
      iex> Expression.Callbacks.percent(%{}, "0.2")
      "20%"
      iex> Expression.Callbacks.percent(%{}, Decimal.new("0.2"))
      "20%"
  """
  @spec percent(Expression.Context.t(), float) :: binary
  def percent(ctx, float) when is_float(float) do
    percent(ctx, Decimal.from_float(float))
  end

  @spec percent(Expression.Context.t(), binary) :: binary
  def percent(ctx, binary) when is_binary(binary) do
    percent(ctx, Decimal.new(binary))
  end

  @spec percent(Expression.Context.t(), Decimal.t()) :: binary
  def percent(_ctx, decimal) do
    Number.Percentage.number_to_percentage(Decimal.mult(decimal, 100), precision: 0)
  end

  @doc """
  Formats digits in text for reading in TTS

  ```
  Your number is @READ_DIGITS(contact.tel_e164)
  ```

  # Example

      iex> Expression.Callbacks.read_digits(%{}, "+271")
      "plus two seven one"

  """
  def read_digits(_ctx, binary) do
    map = %{
      "+" => "plus",
      "0" => "zero",
      "1" => "one",
      "2" => "two",
      "3" => "three",
      "4" => "four",
      "5" => "five",
      "6" => "six",
      "7" => "seven",
      "8" => "eight",
      "9" => "nine"
    }

    binary
    |> String.graphemes()
    |> Enum.map(fn grapheme -> Map.get(map, grapheme, nil) end)
    |> Enum.reject(&is_nil/1)
    |> Enum.join(" ")
  end

  @doc """
  Removes the first word from the given text. The remaining text will be unchanged

  ```
  You entered @REMOVE_FIRST_WORD(step.value)
  ```

  # Example

      iex> Expression.Callbacks.remove_first_word(%{}, "foo bar")
      "bar"
      iex> Expression.Callbacks.remove_first_word(%{}, "foo-bar", "-")
      "bar"
  """
  def remove_first_word(_ctx, binary, separator \\ " ")

  def remove_first_word(_ctx, binary, separator) do
    tl(String.split(binary, separator)) |> Enum.join(separator)
  end

  @doc """
  Extracts the nth word from the given text string. If stop is a negative number,
  then it is treated as count backwards from the end of the text. If by_spaces is
  specified and is TRUE then the function splits the text into words only by spaces.
  Otherwise the text is split by punctuation characters as well

  # Example

      iex> Expression.Callbacks.word(%{}, "hello cow-boy", 2)
      "cow"
      iex> Expression.Callbacks.word(%{}, "hello cow-boy", 2, true)
      "cow-boy"
      iex> Expression.Callbacks.word(%{}, "hello cow-boy", -1)
      "boy"

  """
  def word(ctx, binary, n, by_spaces \\ false)

  def word(_ctx, binary, n, by_spaces) do
    splitter = if(by_spaces, do: " ", else: @punctuation_pattern)
    parts = String.split(binary, splitter)

    # This slicing seems off.
    [part] =
      if n < 0 do
        Enum.slice(parts, n, 1)
      else
        Enum.slice(parts, n - 1, 1)
      end

    part
  end

  @doc """
  Returns the number of words in the given text string. If by_spaces is specified and is TRUE then the function splits the text into words only by spaces. Otherwise the text is split by punctuation characters as well

  ```
  You entered @WORD_COUNT(step.value) words
  ```

  # Example

      iex> Expression.Callbacks.word_count(%{}, "hello cow-boy")
      3
      iex> Expression.Callbacks.word_count(%{}, "hello cow-boy", true)
      2
  """
  def word_count(ctx, binary, by_spaces \\ false)

  def word_count(_ctx, binary, by_spaces) do
    splitter = if(by_spaces, do: " ", else: @punctuation_pattern)

    binary
    |> String.split(splitter)
    |> Enum.count()
  end

  @doc """
  Extracts a substring of the words beginning at start, and up to but not-including stop.
  If stop is omitted then the substring will be all words from start until the end of the text.
  If stop is a negative number, then it is treated as count backwards from the end of the text.
  If by_spaces is specified and is TRUE then the function splits the text into words only by spaces.
  Otherwise the text is split by punctuation characters as well

  # Example

      iex> Expression.Callbacks.word_slice(%{}, "RapidPro expressions are fun", 2, 4)
      "expressions are"
      iex> Expression.Callbacks.word_slice(%{}, "RapidPro expressions are fun", 2)
      "expressions are fun"
      iex> Expression.Callbacks.word_slice(%{}, "RapidPro expressions are fun", 1, -2)
      "RapidPro expressions"
      iex> Expression.Callbacks.word_slice(%{}, "RapidPro expressions are fun", -1)
      "fun"
  """
  def word_slice(_ctx, binary, start) when start > 0 do
    parts =
      binary
      |> String.split(" ")

    parts
    |> Enum.slice(start - 1, length(parts))
    |> Enum.join(" ")
  end

  def word_slice(_ctx, binary, start) when start < 0 do
    parts =
      binary
      |> String.split(" ")

    parts
    |> Enum.slice(start..length(parts))
    |> Enum.join(" ")
  end

  def word_slice(_ctx, binary, start, stop, by_spaces \\ false)

  def word_slice(_ctx, binary, start, stop, by_spaces) when stop > 0 do
    splitter = if(by_spaces, do: " ", else: @punctuation_pattern)

    binary
    |> String.split(splitter)
    |> Enum.slice((start - 1)..(stop - 2))
    |> Enum.join(" ")
  end

  def word_slice(_ctx, binary, start, stop, by_spaces) when stop < 0 do
    splitter = if(by_spaces, do: " ", else: @punctuation_pattern)

    binary
    |> String.split(splitter)
    |> Enum.slice((start - 1)..(stop - 1))
    |> Enum.join(" ")
  end

  @doc """
  Returns TRUE if the argument is a number.

  ```
  @ISNUMBER(contact.age) will return TRUE if the contact's age is a number.
  ```

  # Example

      iex> Expression.Callbacks.isnumber(%{}, 1)
      true
      iex> Expression.Callbacks.isnumber(%{}, 1.0)
      true
      iex> Expression.Callbacks.isnumber(%{}, Decimal.new("1.0"))
      true
      iex> Expression.Callbacks.isnumber(%{}, "1.0")
      true
      iex> Expression.Callbacks.isnumber(%{}, "a")
      false

  """
  def isnumber(_ctx, var) when is_float(var) or is_integer(var), do: true

  def isnumber(_ctx, %{__struct__: Decimal}), do: true

  def isnumber(_ctx, var) when is_binary(var) do
    Decimal.new(var)
    true
  rescue
    Decimal.Error ->
      false
  end

  def isnumber(_ctx, _var), do: false

  @doc """
  Returns TRUE if the argument is a boolean.

  ```
  @ISBOOL(block.value) will return TRUE if the block returned a boolean value.
  ```

  # Example

      iex> Expression.Callbacks.isbool(%{}, true)
      true
      iex> Expression.Callbacks.isbool(%{}, false)
      true
      iex> Expression.Callbacks.isbool(%{}, 1)
      false
      iex> Expression.Callbacks.isbool(%{}, 0)
      false
      iex> Expression.Callbacks.isbool(%{}, "true")
      false
      iex> Expression.Callbacks.isbool(%{}, "false")
      false
  """
  def isbool(_ctx, var) when var in [true, false], do: true
  def isbool(_ctx, _var), do: false

  @doc """
  Returns TRUE if the argument is a string.

  ```
  @ISSTRING(contact.name) will return TRUE if the contact's name is a string.
  ```

  # Example

      iex> Expression.Callbacks.isstring(%{}, "hello")
      true
      iex> Expression.Callbacks.isstring(%{}, false)
      false
      iex> Expression.Callbacks.isstring(%{}, 1)
      false
      iex> Expression.Callbacks.isstring(%{}, Decimal.new("1.0"))
      false
  """
  def isstring(_ctx, binary), do: is_binary(binary)

  defp search_words(haystack, words) do
    patterns =
      words
      |> String.split(" ")
      |> Enum.map(&Regex.escape/1)
      |> Enum.map(&Regex.compile!(&1, "i"))

    results =
      patterns
      |> Enum.map(&Regex.run(&1, haystack))
      |> Enum.map(fn
        [match] -> match
        nil -> nil
      end)
      |> Enum.reject(&is_nil/1)

    {patterns, results}
  end

  @doc """
  Tests whether all the words are contained in text

  The words can be in any order and may appear more than once.

  ```
  @(has_all_words("the quick brown FOX", "the fox")) → true
  @(has_all_words("the quick brown fox", "red fox")) → false
  ```

  NOTE: the flowspec supports `.match` which isn't support here yet.

  ```
  @(has_all_words("the quick brown FOX", "the fox").match) → the FOX
  ```

  # Example

    iex> Expression.Callbacks.has_all_words(%{}, "the quick brown FOX", "the fox")
    {:ok, true}
    iex> Expression.Callbacks.has_all_words(%{}, "the quick brown FOX", "red fox")
    {:ok, false}

  """
  def has_all_words(_ctx, haystack, words) do
    {patterns, results} = search_words(haystack, words)
    # future match result: Enum.join(results, " ")
    {:ok, Enum.count(patterns) == Enum.count(results)}
  end

  @doc """
  Tests whether any of the words are contained in the text

  Only one of the words needs to match and it may appear more than once.

  ```
  @(has_any_word("The Quick Brown Fox", "fox quick")) → true
  ```

  Unsupported:

  ```
  @(has_any_word("The Quick Brown Fox", "fox quick").match) → Quick Fox
  @(has_any_word("The Quick Brown Fox", "red fox").match) → Fox
  ```

  # Example

    iex> Expression.Callbacks.has_any_word(%{}, "The Quick Brown Fox", "fox quick")
    {:ok, true}
    iex> Expression.Callbacks.has_any_word(%{}, "The Quick Brown Fox", "yellow")
    {:ok, false}

  """
  def has_any_word(_ctx, haystack, words) do
    {_patterns, results} = search_words(haystack, words)

    # future match result Enum.join(results, " ")
    {:ok, Enum.any?(results)}
  end

  @doc """
  Tests whether text starts with beginning

  Both text values are trimmed of surrounding whitespace, but otherwise matching is
  strict without any tokenization.

  Supported:

  ```
  @(has_beginning("The Quick Brown", "the quick")) → true
  @(has_beginning("The Quick Brown", "the   quick")) → false
  @(has_beginning("The Quick Brown", "quick brown")) → false
  ```

  Unsupported

  ```
  @(has_beginning("The Quick Brown", "the quick").match) → The Quick
  ```

  # Example

    iex> Expression.Callbacks.has_beginning(%{}, "The Quick Brown", "the quick")
    {:ok, true}
    iex> Expression.Callbacks.has_beginning(%{}, "The Quick Brown", "the    quick")
    {:ok, false}
    iex> Expression.Callbacks.has_beginning(%{}, "The Quick Brown", "quick brown")
    {:ok, false}

  """
  def has_beginning(_ctx, text, beginning) do
    case Regex.run(~r/^#{Regex.escape(beginning)}/i, text) do
      # future match result: first
      [_first | _remainder] -> {:ok, true}
      nil -> {:ok, false}
    end
  end

  defp extract_dateish(expression) do
    expression = Regex.replace(~r/[a-z]/u, expression, "")

    case DateTimeParser.parse_date(expression) do
      {:ok, date} -> date
      {:error, _} -> nil
    end
  end

  @doc """
  Tests whether `expression` contains a date formatted according to our environment

  This is very naively implemented with a regular expression.

  Supported:

  ```
  @(has_date("the date is 15/01/2017")) → true
  @(has_date("there is no date here, just a year 2017")) → false
  ```

  Unsupported:

  ```
  @(has_date("the date is 15/01/2017").match) → 2017-01-15T13:24:30.123456-05:00
  ```

  # Example

    iex> Expression.Callbacks.has_date(%{}, "the date is 15/01/2017")
    {:ok, true}
    iex> Expression.Callbacks.has_date(%{}, "there is no date here, just a year 2017")
    {:ok, false}

  """
  def has_date(_, expression) do
    date = extract_dateish(expression)
    # future match result: date
    {:ok, !!date}
  end

  @doc """
  Tests whether `expression` is a date equal to `date_string`

  Supported:

  ```
  @(has_date_eq("the date is 15/01/2017", "2017-01-15")) → true
  @(has_date_eq("there is no date here, just a year 2017", "2017-06-01")) → false
  @(has_date_eq("there is no date here, just a year 2017", "not date")) → ERROR
  ```

  Not supported:

  ```
  @(has_date_eq("the date is 15/01/2017", "2017-01-15").match) → 2017-01-15T13:24:30.123456-05:00
  @(has_date_eq("the date is 15/01/2017 15:00", "2017-01-15").match) → 2017-01-15T15:00:00.000000-05:00
  ```

  # Examples

    iex> Expression.Callbacks.has_date_eq(%{}, "the date is 15/01/2017", "2017-01-15")
    {:ok, true}
    iex> Expression.Callbacks.has_date_eq(%{}, "there is no date here, just a year 2017", "2017-01-15")
    {:ok, false}
  """
  def has_date_eq(_ctx, expression, date_string) do
    found_date = extract_dateish(expression)
    test_date = extract_dateish(date_string)
    # Future match result: found_date
    {:ok, found_date == test_date}
  end

  @doc """
  Tests whether `expression` is a date after the date `date_string`

  ```
  @(has_date_gt("the date is 15/01/2017", "2017-01-01")) → true
  @(has_date_gt("the date is 15/01/2017", "2017-03-15")) → false
  @(has_date_gt("there is no date here, just a year 2017", "2017-06-01")) → false
  @(has_date_gt("there is no date here, just a year 2017", "not date")) → ERROR
  ```

  Not supported:

  ```
  @(has_date_gt("the date is 15/01/2017", "2017-01-01").match) → 2017-01-15T13:24:30.123456-05:00
  ```

  # Example

    iex> Expression.Callbacks.has_date_gt(%{}, "the date is 15/01/2017", "2017-01-01")
    {:ok, true}
    iex> Expression.Callbacks.has_date_gt(%{}, "the date is 15/01/2017", "2017-03-15")
    {:ok, false}

  """
  def has_date_gt(_ctx, expression, date_string) do
    found_date = extract_dateish(expression)
    test_date = extract_dateish(date_string)
    # future match result: found_date
    {:ok, Date.compare(found_date, test_date) == :gt}
  end

  @doc """
  Tests whether `expression` contains a date before the date `date_string`

  ```
  @(has_date_lt("the date is 15/01/2017", "2017-06-01")) → true
  @(has_date_lt("there is no date here, just a year 2017", "2017-06-01")) → false
  @(has_date_lt("there is no date here, just a year 2017", "not date")) → ERROR
  ```

  Not supported:

  ```
  @(has_date_lt("the date is 15/01/2017", "2017-06-01").match) → 2017-01-15T13:24:30.123456-05:00
  ```

  # Example

    iex> Expression.Callbacks.has_date_lt(%{}, "the date is 15/01/2017", "2017-06-01")
    {:ok, true}
    iex> Expression.Callbacks.has_date_lt(%{}, "the date is 15/01/2021", "2017-03-15")
    {:ok, false}

  """
  def has_date_lt(_ctx, expression, date_string) do
    found_date = extract_dateish(expression)
    test_date = extract_dateish(date_string)
    # future match result: found_date
    {:ok, Date.compare(found_date, test_date) == :lt}
  end

  @doc """
  Tests whether an email is contained in text

  ```
  @(has_email("my email is foo1@bar.com, please respond")) → true
  @(has_email("i'm not sharing my email")) → false
  ```

  Not supported:

  ```
  @(has_email("my email is foo1@bar.com, please respond").match) → foo1@bar.com
  @(has_email("my email is <foo@bar2.com>").match) → foo@bar2.com
  ```

  # Example:

    iex> Expression.Callbacks.has_email(%{}, "my email is foo1@bar.com, please respond")
    {:ok, true}
    iex> Expression.Callbacks.has_email(%{}, "i'm not sharing my email")
    {:ok, false}

  """
  def has_email(_ctx, expression) do
    case Regex.run(~r/([a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+)/, expression) do
      # future match result: match
      [_match | _] -> {:ok, true}
      nil -> {:ok, false}
    end
  end

  @doc """
  Returns whether the contact is part of group with the passed in UUID

  ```
  @(has_group(array(), "97fe7029-3a15-4005-b0c7-277b884fc1d5")) → false
  ```

  Not supported:

  ```
  @(has_group(contact.groups, "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d").match) → {name: Testers, uuid: b7cf0d83-f1c9-411c-96fd-c511a4cfa86d}
  ```

  # Example:

    iex> contact = %{
    ...>   "groups" => [%{
    ...>     "uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"
    ...>   }]
    ...> }
    iex> Expression.Callbacks.has_group(%{}, contact["groups"], "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d")
    {:ok, true}
    iex> Expression.Callbacks.has_group(%{}, contact["groups"], "00000000-0000-0000-0000-000000000000")
    {:ok, false}

  """
  def has_group(_ctx, groups, uuid) do
    group = Enum.find(groups, nil, &(&1["uuid"] == uuid))
    # future match result: group
    {:ok, !!group}
  end

  defp extract_numberish(expression) do
    with [match] <-
           Regex.run(~r/([0-9]+\.?[0-9]+)/u, replace_arabic_numerals(expression), capture: :first),
         {decimal, ""} <- Decimal.parse(match) do
      decimal
    else
      # Regex can return nil
      nil -> nil
      # Decimal parsing can return :error
      :error -> nil
    end
  end

  defp replace_arabic_numerals(expression) do
    replace_numerals(expression, %{
      "٠" => "0",
      "١" => "1",
      "٢" => "2",
      "٣" => "3",
      "٤" => "4",
      "٥" => "5",
      "٦" => "6",
      "٧" => "7",
      "٨" => "8",
      "٩" => "9"
    })
  end

  defp replace_numerals(expression, mapping) do
    mapping
    |> Enum.reduce(expression, fn {rune, replacement}, expression ->
      String.replace(expression, rune, replacement)
    end)
  end

  defp parse_decimal(float) when is_float(float), do: Decimal.from_float(float)

  defp parse_decimal(number) when is_number(number), do: Decimal.new(number)

  defp parse_decimal(binary) when is_binary(binary) do
    case Decimal.parse(binary) do
      {decimal, ""} -> decimal
      :error -> :error
    end
  end

  @doc """
  Tests whether `expression` contains a number

  ```
  @(has_number("the number is 42")) → true
  @(has_number("the number is forty two")) → false
  ```

  Not supported:

  ```
  @(has_number("the number is 42").match) → 42
  @(has_number("العدد ٤٢").match) → 42
  ```

  # Example

    iex> {:ok, true} = Expression.Callbacks.has_number(%{}, "the number is 42 and 5")
    iex> {:ok, true} = Expression.Callbacks.has_number(%{}, "العدد ٤٢")
    iex> {:ok, true} = Expression.Callbacks.has_number(%{}, "٠.٥")
    iex> {:ok, true} = Expression.Callbacks.has_number(%{}, "0.6")

  """
  def has_number(_ctx, expression) do
    number = extract_numberish(expression)
    # future match result: number
    {:ok, !!number}
  end

  @doc """
  Tests whether `expression` contains a number equal to the value

  ```
  @(has_number_eq("the number is 42", 42)) → true
  @(has_number_eq("the number is 42", 40)) → false
  @(has_number_eq("the number is not there", 40)) → false
  @(has_number_eq("the number is not there", "foo")) → ERROR
  ```

  Not supported:

  ```
  @(has_number_eq("the number is 42", 42).match) → 42
  ```

  # Example

    iex> {:ok, true} = Expression.Callbacks.has_number_eq(%{}, "the number is 42", 42)
    iex> {:ok, true} = Expression.Callbacks.has_number_eq(%{}, "the number is 42", 42.0)
    iex> {:ok, true} = Expression.Callbacks.has_number_eq(%{}, "the number is 42", "42")
    iex> {:ok, true} = Expression.Callbacks.has_number_eq(%{}, "the number is 42.0", "42")
    iex> {:ok, false} = Expression.Callbacks.has_number_eq(%{}, "the number is 40", "42")
    iex> {:ok, false} = Expression.Callbacks.has_number_eq(%{}, "the number is 40", "foo")
    iex> {:ok, false} = Expression.Callbacks.has_number_eq(%{}, "four hundred", "foo")

  """
  def has_number_eq(_ctx, expression, decimal) do
    with %Decimal{} = number <- extract_numberish(expression),
         %Decimal{} = decimal <- parse_decimal(decimal) do
      # Future match result: number
      {:ok, Decimal.eq?(number, decimal)}
    else
      nil -> {:ok, false}
      :error -> {:ok, false}
    end
  end

  @doc """
  Tests whether `expression` contains a number greater than min

  ```
  @(has_number_gt("the number is 42", 40)) → true
  @(has_number_gt("the number is 42", 42)) → false
  @(has_number_gt("the number is not there", 40)) → false
  @(has_number_gt("the number is not there", "foo")) → ERROR
  ```

  Not supported:

  ```
  @(has_number_gt("the number is 42", 40).match) → 42
  ```

  # Example

    iex> {:ok, true} = Expression.Callbacks.has_number_gt(%{}, "the number is 42", 40)
    iex> {:ok, true} = Expression.Callbacks.has_number_gt(%{}, "the number is 42", 40.0)
    iex> {:ok, true} = Expression.Callbacks.has_number_gt(%{}, "the number is 42", "40")
    iex> {:ok, true} = Expression.Callbacks.has_number_gt(%{}, "the number is 42.0", "40")
    iex> {:ok, false} = Expression.Callbacks.has_number_gt(%{}, "the number is 40", "40")
    iex> {:ok, false} = Expression.Callbacks.has_number_gt(%{}, "the number is 40", "foo")
    iex> {:ok, false} = Expression.Callbacks.has_number_gt(%{}, "four hundred", "foo")
  """
  def has_number_gt(_ctx, expression, decimal) do
    with %Decimal{} = number <- extract_numberish(expression),
         %Decimal{} = decimal <- parse_decimal(decimal) do
      # Future match result: number
      {:ok, Decimal.gt?(number, decimal)}
    else
      nil -> {:ok, false}
      :error -> {:ok, false}
    end
  end

  @doc """
  Tests whether `expression` contains a number greater than or equal to min

  ```
  @(has_number_gte("the number is 42", 42)) → true
  @(has_number_gte("the number is 42", 45)) → false
  @(has_number_gte("the number is not there", 40)) → false
  @(has_number_gte("the number is not there", "foo")) → ERROR
  ```

  Not supported:

  ```
  @(has_number_gte("the number is 42", 42).match) → 42
  ```

  # Example

    iex> {:ok, true} = Expression.Callbacks.has_number_gte(%{}, "the number is 42", 42)
    iex> {:ok, true} = Expression.Callbacks.has_number_gte(%{}, "the number is 42", 42.0)
    iex> {:ok, true} = Expression.Callbacks.has_number_gte(%{}, "the number is 42", "42")
    iex> {:ok, false} = Expression.Callbacks.has_number_gte(%{}, "the number is 42.0", "45")
    iex> {:ok, false} = Expression.Callbacks.has_number_gte(%{}, "the number is 40", "45")
    iex> {:ok, false} = Expression.Callbacks.has_number_gte(%{}, "the number is 40", "foo")
    iex> {:ok, false} = Expression.Callbacks.has_number_gte(%{}, "four hundred", "foo")
  """
  def has_number_gte(_ctx, expression, decimal) do
    with %Decimal{} = number <- extract_numberish(expression),
         %Decimal{} = decimal <- parse_decimal(decimal) do
      # Future match result: number
      {:ok, Decimal.gt?(number, decimal) || Decimal.eq?(number, decimal)}
    else
      nil -> {:ok, false}
      :error -> {:ok, false}
    end
  end

  @doc """
  Tests whether `expression` contains a number less than max

  ```
  @(has_number_lt("the number is 42", 44)) → true
  @(has_number_lt("the number is 42", 40)) → false
  @(has_number_lt("the number is not there", 40)) → false
  @(has_number_lt("the number is not there", "foo")) → ERROR
  ```

  Not supported:

  ```
  @(has_number_lt("the number is 42", 44).match) → 42
  ```

  # Example

    iex> {:ok, true} = Expression.Callbacks.has_number_lt(%{}, "the number is 42", 44)
    iex> {:ok, true} = Expression.Callbacks.has_number_lt(%{}, "the number is 42", 44.0)
    iex> {:ok, false} = Expression.Callbacks.has_number_lt(%{}, "the number is 42", "40")
    iex> {:ok, false} = Expression.Callbacks.has_number_lt(%{}, "the number is 42.0", "40")
    iex> {:ok, false} = Expression.Callbacks.has_number_lt(%{}, "the number is 40", "40")
    iex> {:ok, false} = Expression.Callbacks.has_number_lt(%{}, "the number is 40", "foo")
    iex> {:ok, false} = Expression.Callbacks.has_number_lt(%{}, "four hundred", "foo")
  """
  def has_number_lt(_ctx, expression, decimal) do
    with %Decimal{} = number <- extract_numberish(expression),
         %Decimal{} = decimal <- parse_decimal(decimal) do
      # Future match result: number
      {:ok, Decimal.lt?(number, decimal)}
    else
      nil -> {:ok, false}
      :error -> {:ok, false}
    end
  end

  @doc """
  Tests whether `expression` contains a number less than or equal to max

  ```
  @(has_number_lte("the number is 42", 42)) → true
  @(has_number_lte("the number is 42", 40)) → false
  @(has_number_lte("the number is not there", 40)) → false
  @(has_number_lte("the number is not there", "foo")) → ERROR
  ```

  Not supported:

  ```
  @(has_number_lte("the number is 42", 42).match) → 42
  ```

  # Example

    iex> {:ok, true} = Expression.Callbacks.has_number_lte(%{}, "the number is 42", 42)
    iex> {:ok, true} = Expression.Callbacks.has_number_lte(%{}, "the number is 42", 42.0)
    iex> {:ok, true} = Expression.Callbacks.has_number_lte(%{}, "the number is 42", "42")
    iex> {:ok, false} = Expression.Callbacks.has_number_lte(%{}, "the number is 42.0", "40")
    iex> {:ok, false} = Expression.Callbacks.has_number_lte(%{}, "the number is 40", "foo")
    iex> {:ok, false} = Expression.Callbacks.has_number_lte(%{}, "four hundred", "foo")

  """
  def has_number_lte(_ctx, expression, decimal) do
    with %Decimal{} = number <- extract_numberish(expression),
         %Decimal{} = decimal <- parse_decimal(decimal) do
      # Future match result: number
      {:ok, Decimal.lt?(number, decimal) || Decimal.eq?(number, decimal)}
    else
      nil -> {:ok, false}
      :error -> {:ok, false}
    end
  end

  @doc """
  Tests whether the text contains only phrase

  The phrase must be the only text in the text to match

  ```
  @(has_only_phrase("Quick Brown", "quick brown")) → true
  @(has_only_phrase("The Quick Brown Fox", "quick brown")) → false
  @(has_only_phrase("the Quick Brown fox", "")) → false
  @(has_only_phrase("", "").match) →
  @(has_only_phrase("The Quick Brown Fox", "red fox")) → false
  ```

  Not supported:

  ```
  @(has_only_phrase("Quick Brown", "quick brown").match) → Quick Brown
  ```

  # Example

    iex> Expression.Callbacks.has_only_phrase(%{}, "Quick Brown", "quick brown")
    {:ok, true}
    iex> Expression.Callbacks.has_only_phrase(%{}, "", "")
    {:ok, true}
    iex> Expression.Callbacks.has_only_phrase(%{}, "The Quick Brown Fox", "quick brown")
    {:ok, false}

  """
  def has_only_phrase(_ctx, expression, phrase) do
    case Enum.map([expression, phrase], &String.downcase/1) do
      # Future match result: expression
      [same, same] -> {:ok, true}
      _anything_else -> {:ok, false}
    end
  end

  @doc """
  Returns whether two text values are equal (case sensitive). In the case that they are, it will return the text as the match.

  ```
  @(has_only_text("foo", "foo")) → true
  @(has_only_text("foo", "FOO")) → false
  @(has_only_text("foo", "bar")) → false
  @(has_only_text("foo", " foo ")) → false
  @(has_only_text(results.webhook.category, "Failure")) → false
  ```

  Not supported:

  ```
  @(has_only_text("foo", "foo").match) → foo
  @(has_only_text(run.status, "completed").match) → completed
  @(has_only_text(results.webhook.category, "Success").match) → Success
  ```

  # Example

    iex> Expression.Callbacks.has_only_text(%{}, "foo", "foo")
    {:ok, true}
    iex> Expression.Callbacks.has_only_text(%{}, "", "")
    {:ok, true}
    iex> Expression.Callbacks.has_only_text(%{}, "foo", "FOO")
    {:ok, false}

  """
  def has_only_text(_ctx, expression, expression) when is_binary(expression),
    # future match result: expression
    do: {:ok, true}

  def has_only_text(_ctx, _expression, _something_else),
    # Future match result: expression
    do: {:ok, false}

  @doc """
  Tests whether `expression` matches the regex pattern

  Both text values are trimmed of surrounding whitespace and matching is case-insensitive.

  ```
  @(has_pattern("Buy cheese please", "buy (\w+)")) → true
  @(has_pattern("Sell cheese please", "buy (\w+)")) → false
  ```

  Not supported:

  ```
  @(has_pattern("Buy cheese please", "buy (\w+)").match) → Buy cheese
  @(has_pattern("Buy cheese please", "buy (\w+)").extra) → {0: Buy cheese, 1: cheese}
  ```

  # Examples

    iex> Expression.Callbacks.has_pattern(%{}, "Buy cheese please", "buy (\\\\w+)")
    {:ok, true}
    iex> Expression.Callbacks.has_pattern(%{}, "Sell cheese please", "buy (\\\\w+)")
    {:ok, false}

  """
  def has_pattern(_ctx, expression, pattern) do
    with {:ok, regex} <- Regex.compile(String.trim(pattern), "i"),
         [[_first | _remainder]] <- Regex.scan(regex, String.trim(expression), capture: :all) do
      # Future match result: first
      {:ok, true}
    else
      _ -> {:ok, false}
    end
  end

  @doc """
  Tests whether `expresssion` contains a phone number.
  The optional country_code argument specifies the country to use for parsing.

  ```
  @(has_phone("my number is +12067799294 thanks")) → true
  @(has_phone("my number is none of your business", "US")) → false
  ```

  Not supported:

  ```
  @(has_phone("my number is +12067799294").match) → +12067799294
  @(has_phone("my number is 2067799294", "US").match) → +12067799294
  @(has_phone("my number is 206 779 9294", "US").match) → +12067799294
  ```

  # Example

    iex> Expression.Callbacks.has_phone(%{}, "my number is +12067799294 thanks")
    {:ok, true}
    iex> Expression.Callbacks.has_phone(%{}, "my number is 2067799294 thanks", "US")
    {:ok, true}
    iex> Expression.Callbacks.has_phone(%{}, "my number is 206 779 9294 thanks", "US")
    {:ok, true}
    iex> Expression.Callbacks.has_phone(%{}, "my number is none of your business", "US")
    {:ok, false}

  """
  def has_phone(%{}, expression, country_code \\ "") do
    letters_removed = Regex.replace(~r/[a-z]/i, expression, "")

    case ExPhoneNumber.parse(letters_removed, country_code) do
      # Future match result: ExPhoneNumber.format(pn, :es164)
      {:ok, _pn} -> {:ok, true}
      _ -> {:ok, false}
    end
  end

  @doc """
  Tests whether phrase is contained in `expression`

  The words in the test phrase must appear in the same order with no other words in between.

  ```
  @(has_phrase("the quick brown fox", "brown fox")) → true
  @(has_phrase("the Quick Brown fox", "quick fox")) → false
  @(has_phrase("the Quick Brown fox", "").match) →
  ```

  Not supported:

  ```
  @(has_phrase("the quick brown fox", "brown fox").match) → brown fox
  ```

  # Examples

    iex> Expression.Callbacks.has_phrase(%{}, "the quick brown fox", "brown fox")
    {:ok, true}
    iex> Expression.Callbacks.has_phrase(%{}, "the quick brown fox", "quick fox")
    {:ok, false}
    iex> Expression.Callbacks.has_phrase(%{}, "the quick brown fox", "")
    {:ok, true}

  """
  def has_phrase(_ctx, expression, phrase) do
    lower_expression = String.downcase(expression)
    lower_phrase = String.downcase(phrase)
    found? = String.contains?(lower_expression, lower_phrase)
    # Future match result: phrase
    {:ok, found?}
  end

  @doc """
  Tests whether there the `expression` has any characters in it

  ```
  @(has_text("quick brown")) → true
  @(has_text("")) → false
  @(has_text(" \n")) → false
  @(has_text(contact.fields.not_set)) → false
  ```

  Not supported:

  ```
  @(has_text("quick brown").match) → quick brown
  @(has_text(123).match) → 123
  ```

  # Examples

    iex> Expression.Callbacks.has_text(%{}, "quick brown")
    {:ok, true}
    iex> Expression.Callbacks.has_text(%{}, "")
    {:ok, false}
    iex> Expression.Callbacks.has_text(%{}, " \\n")
    {:ok, false}
    iex> Expression.Callbacks.has_text(%{}, 123)
    {:ok, true}
    iex> Expression.Callbacks.has_text(%{}, nil)
    {:ok, false}
  """
  def has_text(ctx, expression) when not is_binary(expression),
    do: has_text(ctx, to_string(expression))

  def has_text(_ctx, expression) when is_binary(expression) do
    case String.trim(expression) do
      "" -> {:ok, false}
      # Future match result: any_other_binary
      _any_other_binary -> {:ok, true}
    end
  end

  @doc """
  Tests whether `expression` contains a time.

  ```
  @(has_time("the time is 10:30")) → true
  @(has_time("the time is 10:30:45").match) → 10:30:45.000000
  @(has_time("there is no time here, just the number 25")) → false
  ```

  Not supported:

  ```
  @(has_time("the time is 10:30").match) → 10:30:00.000000
  @(has_time("the time is 10 PM").match) → 22:00:00.000000
  ```

  # Examples

    iex> Expression.Callbacks.has_time(%{}, "the time is 10:30")
    {:ok, true}
    iex> Expression.Callbacks.has_time(%{}, "the time is 10:00 pm")
    {:ok, true}
    iex> Expression.Callbacks.has_time(%{}, "the time is 10:30:45")
    {:ok, true}
    iex> Expression.Callbacks.has_time(%{}, "there is no time here, just the number 25")
    {:ok, false}

  """
  def has_time(_ctx, expression) do
    case DateTimeParser.parse_time(expression) do
      # Future match result: time
      {:ok, _time} -> {:ok, true}
      _ -> {:ok, false}
    end
  end
end