defmodule Re do
  @moduledoc """
  Write readable regular expressions in functional style.

  ## Examples

  Match subdomains of `example.com`:

    iex> require Re
    iex> require Re.Chars
    iex> regex =
    ...>   Re.sequence([
    ...>     Re.one_or_more(Re.any_of([Re.Chars.any_ascii, Re.any_of('.-_')])),
    ...>     Re.text(".example.com")
    ...>   ]) |> Re.compile()
    ~r/(?:[\\\\0-\\x7f]|\\.|\\-|_)+\\.example\\.com/
    iex> "hello.example.com" =~ regex
    true
    iex> "hello.world.example.com" =~ regex
    true
    iex> "hello.orsinium.dev" =~ regex
    false

  """

  require Re.Chars

  @typedoc """
  internal Re representation of regular expressions.
  """
  @opaque re_ast :: {:re_expr, String.t()} | {:re_group, String.t()}

  @doc """
  Guard for matching the internal Re AST representation.

  ## Examples

      iex> Re.is_re(Re.text("hello"))
      true
      iex> Re.is_re("something else")
      false
      iex> Re.is_re(~r"hi")
      false
  """
  @spec is_re(any) :: any
  defguard is_re(v)
           when is_tuple(v) and tuple_size(v) == 2 and
                  (elem(v, 0) == :re_expr or elem(v, 0) == :re_group)

  # Internal macros that evaluates quoted expression if all params are static literals.
  defmacrop eager(params, do: block) do
    quote generated: true do
      if Macro.quoted_literal?(unquote(params)) do
        {term, _} = unquote(block) |> Code.eval_quoted()
        Macro.escape(term)
      else
        unquote(block)
      end
    end
  end

  @doc """
  Convert the given Re AST into a string.

  ## Examples

    iex> Re.to_string(Re.Chars.any_digit)
    "\\\\d"
    iex> Re.to_string(Re.Chars.any_ascii)
    "[\\\\\\\\0-\\\\x7f]"
  """
  @spec to_string(re_ast() | String.t() | char()) :: String.t()
  defmacro to_string(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        case unquote(expr) do
          {t, result} when is_atom(t) ->
            result

          result when is_integer(result) ->
            to_string([result]) |> Regex.escape()

          result when is_bitstring(result) ->
            result
        end
      end
    end
  end

  @doc """
  Compile Re AST (or string) into native Regex type.

  The result can be used with any functions from the Regex module.

  https://hexdocs.pm/elixir/1.13/Regex.html#compile!/2

  ## Examples

    iex> "1" =~ Re.compile(Re.Chars.any_digit)
    true
    iex> "a" =~ Re.compile(Re.Chars.any_digit)
    false
  """
  @spec compile(re_ast() | String.t(), binary() | [term()]) :: any()
  defmacro compile(expr, options \\ "") do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        require Re
        unquote(expr) |> Re.to_string() |> Regex.compile!(unquote(options))
      end
    end
  end

  @doc """
  Group (but not capture) the pattern if needed.

  Usually, you don't need to call this function.
  All other functions call this one when needed.

  PCRE: `(?:X)`

  ## Examples

    iex> 'abc' |> Re.raw |> Re.group |> Re.to_string
    "(?:abc)"
  """
  @spec group(re_ast() | String.t()) :: re_ast()
  defmacro group(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        case unquote(expr) do
          {:re_expr, val} -> {:re_group, "(?:#{val})"}
          {:re_group, val} = expr -> expr
          val when is_integer(val) -> {:re_group, to_string([val])}
          val when byte_size(val) == 1 -> {:re_group, to_string([val])}
          val -> {:re_group, "(?:#{val})"}
        end
      end
    end
  end

  @doc """
  Include a raw regex as is into the resulting pattern.

  Can be dangerous. Don't let untrusted users to pass values there.
  Use `Re.text` if you need the input text to be escaped.

  ## Examples

    iex> "example.com" =~ Re.raw("example.com") |> Re.compile()
    true
    iex> "examplescom" =~ Re.raw("example.com") |> Re.compile()
    true
    iex> "examplscom" =~ Re.raw("example.com") |> Re.compile()
    false

  """
  @spec raw(String.t() | Regex.t()) :: re_ast()
  defmacro raw(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        case unquote(expr) do
          %Regex{} = val -> {:re_expr, Regex.source(val)}
          val -> {:re_expr, val}
        end
      end
    end
  end

  @doc """
  Include a text into the resulting pattern.
  All unsafe symbols will be escaped if necessary.

  ## Examples

    iex> rex = Re.text("example.com") |> Re.compile()
    iex> "example.com" =~ rex
    true
    iex> "examplescom" =~ rex
    false

  """
  @spec text(String.t() | integer()) :: re_ast()
  defmacro text(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        case unquote(expr) do
          val when is_integer(val) -> {:re_group, Regex.escape(to_string([val]))}
          val when byte_size(val) == 1 -> {:re_group, Regex.escape(val)}
          val -> {:re_expr, Regex.escape(val)}
        end
      end
    end
  end

  @doc """
  Chain multiple patterns together.

  PCRE: `XY`

  ## Examples

    iex> rex = Re.sequence([Re.text("a"), Re.Chars.any_digit]) |> Re.compile
    iex> "a1" =~ rex
    true
    iex> "a" =~ rex
    false
    iex> "1" =~ rex
    false

  """
  @spec sequence([re_ast() | String.t()]) :: re_ast()
  defmacro sequence(exprs) do
    exprs = exprs |> Enum.map(&Macro.expand(&1, __ENV__))

    eager exprs do
      quote generated: true do
        require Re
        result = unquote(exprs) |> Enum.map(&Re.to_string/1) |> Enum.join()
        {:re_expr, result}
      end
    end
  end

  @doc """
  Match any of the given patters or symbols.

  PCRE: `[XY]` and `X|Y`

  ## Examples

    iex> rex = Re.any_of([Re.text(?a), Re.text(?b)]) |> Re.compile
    iex> "a" =~ rex
    true
    iex> "b" =~ rex
    true
    iex> "c" =~ rex
    false
    iex> "a" =~ Re.any_of([?a, ?b]) |> Re.compile
    true
  """
  @spec any_of([re_ast() | String.t() | char()]) :: re_ast()
  defmacro any_of(exprs) do
    exprs = exprs |> Enum.map(&Macro.expand(&1, __ENV__))

    eager exprs do
      quote generated: true do
        require Re
        strings = unquote(exprs) |> Enum.map(&Re.to_string/1)

        if strings |> Enum.all?(&(byte_size(&1) == 1)) do
          {:re_group, "[#{Enum.join(strings)}]"}
        else
          {:re_expr, Enum.join(strings, "|")}
        end
      end
    end
  end

  @doc """
  Match anything except the given symbols.

  PCRE: `[^XY]`

  ## Examples

    iex> "a" =~ Re.none_of('abc') |> Re.compile()
    false
    iex> "d" =~ Re.none_of('abc') |> Re.compile()
    true

  """
  @spec none_of(list(char())) :: re_ast()
  defmacro none_of(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        {:re_group, "[^#{unquote(expr)}]"}
      end
    end
  end

  @doc """
  Match any symbol in the given range.

  PCRE: `[X-Y]`

  ## Examples

    iex> rex = Re.in_range(?a, ?d) |> Re.compile()
    ~r/[a-d]/
    iex> "a" =~ rex
    true
    iex> "c" =~ rex
    true
    iex> "d" =~ rex
    true
    iex> "e" =~ rex
    false

  """
  @spec in_range(char(), char()) :: re_ast()
  defmacro in_range(expr1, expr2) do
    expr1 = Macro.expand(expr1, __ENV__)
    expr2 = Macro.expand(expr2, __ENV__)

    eager [expr1, expr2] do
      quote bind_quoted: [expr1: expr1, expr2: expr2] do
        val1 =
          cond do
            is_integer(expr1) -> to_string([expr1])
            true -> expr1
          end

        val2 =
          cond do
            is_integer(expr2) -> to_string([expr2])
            true -> expr2
          end

        {:re_expr, "[#{val1}-#{val2}]"}
      end
    end
  end

  @doc """
  Match zero or more repetitions of the pattern.

  PCRE: `X*`
  """
  @spec zero_or_more(any) :: re_ast()
  defmacro zero_or_more(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        require Re
        {:re_group, value} = Re.group(unquote(expr))
        {:re_group, "#{value}*"}
      end
    end
  end

  @doc """
  Match one or more repetitions of the pattern.

  PCRE: `X+`

  ## Examples

    iex> "a" =~ "a" |> Re.text |> Re.one_or_more |> Re.compile()
    true
    iex> "aaa" =~ "a" |> Re.text |> Re.one_or_more |> Re.compile()
    true
    iex> "b" =~ "a" |> Re.text |> Re.one_or_more |> Re.compile()
    false
    iex> "" =~ "a" |> Re.text |> Re.one_or_more |> Re.compile()
    false

  """
  @spec one_or_more(any) :: re_ast()
  defmacro one_or_more(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        require Re
        {:re_group, value} = Re.group(unquote(expr))
        {:re_group, "#{value}+"}
      end
    end
  end

  @doc """
  Match zero or one repetition of the pattern.

  PCRE: `X?`
  """
  @spec optional(any) :: re_ast()
  defmacro optional(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        require Re
        {:re_group, value} = Re.group(unquote(expr))
        {:re_group, "#{value}?"}
      end
    end
  end

  @doc """
  Match exactly N repetitions of the pattern.

  PCRE: `X{N}`

  ## Examples

    iex(21)> rex = Re.text("ab") |> Re.repeated(2) |> Re.compile
    ~r/(?:ab){2}/
    iex(22)> "ab" =~ rex
    false
    iex(23)> "abab" =~ rex
    true

  """
  @spec repeated(re_ast() | String.t(), integer()) :: re_ast()
  defmacro repeated(expr, n) do
    expr = Macro.expand(expr, __ENV__)
    n = Macro.expand(n, __ENV__)

    eager [expr, n] do
      quote generated: true do
        require Re
        {:re_group, val} = unquote(expr) |> Re.group()
        {:re_group, "#{val}{#{unquote(n)}}"}
      end
    end
  end

  @doc """
  Match from at_least to at_most repetitions of the pattern.

  PCRE: `X{N,M}`
  """
  @spec repeated(any, any, any) :: re_ast()
  defmacro repeated(expr, at_least, at_most) do
    expr = Macro.expand(expr, __ENV__)
    at_least = Macro.expand(at_least, __ENV__)
    at_most = Macro.expand(at_most, __ENV__)

    eager [expr, at_least, at_most] do
      quote generated: true do
        require Re
        {:re_group, val} = unquote(expr) |> Re.group()
        {:re_group, "#{val}{#{unquote(at_least)},#{unquote(at_most)}}"}
      end
    end
  end

  @doc """
  Capture the pattern.

  https://hexdocs.pm/elixir/1.13/Regex.html#module-captures

  PCRE: `(X)`

  ## Examples

    iex> rex = Re.sequence([Re.text(?a), Re.capture(Re.Chars.any_digit)]) |> Re.compile
    ~r/a(\\d)/
    iex> Regex.run(rex, "a1", capture: :all_but_first)
    ["1"]
  """
  @spec capture(any) :: re_ast()
  defmacro capture(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        require Re
        val = unquote(expr) |> Re.to_string()
        {:re_group, "(#{val})"}
      end
    end
  end

  @doc """
  Named capture of the pattern.

  https://hexdocs.pm/elixir/1.13/Regex.html#module-captures

  PCRE: `(?P<N>X)`

  ## Examples

    iex> rex = Re.sequence([Re.text(?a), Re.capture(Re.Chars.any_digit, "number")]) |> Re.compile
    ~r/a(?P<number>\\d)/
    iex> Regex.named_captures(rex, "a1")
    %{"number" => "1"}
  """
  @spec capture(any, any) :: re_ast()
  defmacro capture(expr, name) do
    expr = Macro.expand(expr, __ENV__)
    name = Macro.expand(name, __ENV__)

    eager [expr, name] do
      quote generated: true do
        require Re
        val = unquote(expr) |> Re.to_string()
        {:re_group, "(?P<#{unquote(name)}>#{val})"}
      end
    end
  end

  @doc """
  "Ungreedy" the pattern.

  By default, all patterns greedy and try to match as much as possbile.
  This function reverts this behavior for the given pattern,
  making it match as less as possible.

  https://hexdocs.pm/elixir/1.13/Regex.html#module-captures

  PCRE: `X?`

  ## Examples

    iex> rex = Re.sequence([
    ...>  Re.text(?a),
    ...>  Re.Chars.any_digit |> Re.one_or_more() |> Re.capture
    ...> ]) |> Re.compile()
    ~r/a(\\d+)/
    iex> Regex.run(rex, "a111", capture: :all_but_first)
    ["111"]
    iex> rex = Re.sequence([
    ...>  Re.text(?a),
    ...>  Re.Chars.any_digit |> Re.one_or_more() |> Re.lazy |> Re.capture
    ...> ]) |> Re.compile()
    ~r/a(\\d+?)/
    iex> Regex.run(rex, "a111", capture: :all_but_first)
    ["1"]

  """
  @spec lazy(re_ast()) :: re_ast()
  defmacro lazy(expr) do
    expr = Macro.expand(expr, __ENV__)

    eager [expr] do
      quote generated: true do
        require Re
        {:re_group, value} = unquote(expr)
        {:re_group, "#{value}?"}
      end
    end
  end
end