defmodule DotenvParser do
  @moduledoc """
  Simple parser for dotenv style files.

  Supports simple variable–value pairs with upper and lower cased variables. Values are trimmed of extra whitespace.

  Blank lines and lines starting with `#` are ignored. Additionally inline comments can be added after values with a
  `#`, i.e. `FOO=bar # comment`.

  Single quote or double quote value to prevent trimming of whitespace and allow usage of `#` in value, i.e. `FOO='  bar # not comment ' # comment`.

  Single quoted values don't do any unescaping. Double quoted values will unescape the following:

  * `\\n` - Linefeed
  * `\\r` - Carriage return
  * `\\t` - Tab
  * `\\f` - Form feed
  * `\\b` - Backspace
  * `\\"` and `\\'` - Quotes
  * `\\\\` - Backslash
  * `\\uFFFF` - Unicode escape (4 hex characters to denote the codepoint)
  * A backslash at the end of the line in a multiline value will remove the linefeed.

  Values can span multiple lines when single or double quoted:

  ```sh
  MULTILINE="This is a
  multiline value."
  ```

  This will result in the following:

  ```elixir
  System.fetch_env!("MULTILINE") == "This is a\\nmultiline value."
  ```

  A line can start with `export ` for easier interoperation with regular shell scripts. These lines are treated the
  same as any others.

  ## Serving suggestion

  If you load lots of environment variables in `config/runtime.exs`, you can easily configure them for development by
  having an `.env` file in your development environment and using DotenvParser at the start of the file:

  ```elixir
  import Config

  if Config.config_env() == :dev do
    DotenvParser.load_file(".env")
  end

  # Now variables from `.env` are loaded into system env
  config :your_project,
    database_url: System.fetch_env!("DB_URL")
  """

  @linefeed_re ~r/\r?\n/
  @line_re ~r/^(?:\s*export)?\s*[a-z_][a-z_0-9]*\s*=/i
  @dquoted_val_re ~r/^"([^"\\]*(?:\\.[^"\\]*)*)"\s*(?:#.*)?$/
  @squoted_val_re ~r/^\s*'(.*)'\s*(?:#.*)?$/
  @dquoted_multiline_end ~r/^([^"\\]*(?:\\.[^"\\]*)*)"\s*(?:#.*)?$/
  @squoted_multiline_end ~r/^(.*)'\s*(?:#.*)?$/
  @hex_re ~r/^[0-9a-f]+$/i

  @quote_chars ~w(" ')

  @typedoc "Pair of variable name, variable value."
  @type value_pair :: {String.t(), String.t()}

  defmodule ParseError do
    @moduledoc "Error raised when a line cannot be parsed."
    defexception [:message]
  end

  defmodule Continuation do
    @typedoc """
    A multiline value continuation. When a function returns this, it means that a multiline value
    was started and more needs to be parsed to get the rest of the value.
    """
    @type t :: %__MODULE__{
            name: String.t(),
            value: String.t(),
            start_quote: String.t()
          }
    @enforce_keys [:name, :value, :start_quote]
    defstruct [:name, :value, :start_quote]
  end

  @doc """
  Parse given file and load the variables to the environment.

  If a line cannot be parsed or the file cannot be read, an error is raised and no values are loaded to the
  environment.
  """
  @spec load_file(String.t()) :: :ok
  def load_file(file) do
    file
    |> File.read!()
    |> load_data()
  end

  @doc """
  Parse given data and load the variables to the environment.

  If a line cannot be parsed, an error is raised and no values are loaded to the environment.
  """
  @spec load_data(String.t()) :: :ok
  def load_data(data) do
    data
    |> parse_data()
    |> Enum.each(fn {var, val} -> System.put_env(var, val) end)
  end

  @doc """
  Parse given file and return a list of variable–value tuples.

  If a line cannot be parsed or the file cannot be read, an error is raised.
  """
  @spec parse_file(String.t()) :: [value_pair()]
  def parse_file(file) do
    file
    |> File.read!()
    |> parse_data()
  end

  @doc """
  Parse given data and return a list of variable–value tuples.

  If a line cannot be parsed, an error is raised.
  """
  @spec parse_data(String.t()) :: [value_pair()]
  def parse_data(data) do
    {value_pairs, continuation} =
      data
      |> String.split(@linefeed_re)
      |> Enum.reduce({[], nil}, fn
        line, {ret, nil} ->
          trimmed = String.trim(line)

          if not is_comment?(trimmed) and not is_blank?(trimmed) do
            reduce_line(ret, line, nil)
          else
            {ret, nil}
          end

        line, {ret, continuation} ->
          reduce_line(ret, line, continuation)
      end)

    if not is_nil(continuation) do
      raise ParseError,
            "Could not find end for quote #{continuation.start_quote} in variable #{continuation.name}"
    end

    Enum.reverse(value_pairs)
  end

  @doc """
  Parse given single line and return a variable–value tuple, or a continuation value if the line
  started or continued a multiline value.

  If line cannot be parsed, an error is raised.

  The second argument needs to be `nil` or a continuation value returned from parsing the previous
  line.
  """
  @spec parse_line(String.t(), Continuation.t() | nil) :: value_pair() | Continuation.t()
  def parse_line(line, state)

  def parse_line(line, nil) do
    if not Regex.match?(@line_re, line) do
      raise ParseError, "Malformed line cannot be parsed: #{line}"
    else
      [var, val] = String.split(line, "=", parts: 2)
      var = var |> String.trim() |> String.replace_leading("export ", "")
      trimmed = String.trim(val)

      with {:dquoted, nil} <- {:dquoted, Regex.run(@dquoted_val_re, trimmed)},
           {:squoted, nil} <- {:squoted, Regex.run(@squoted_val_re, trimmed)},
           trimmed_leading = String.trim_leading(val),
           {:quoted_start, false} <-
             {:quoted_start, String.starts_with?(trimmed_leading, @quote_chars)} do
        # Value is plain value
        {var, trimmed |> remove_comment() |> String.trim()}
      else
        {:dquoted, [_, inner_val]} ->
          {var, stripslashes(inner_val)}

        {:squoted, [_, inner_val]} ->
          {var, inner_val}

        {:quoted_start, _} ->
          parse_multiline_start(var, val)
      end
    end
  end

  def parse_line(line, %Continuation{} = continuation) do
    trimmed = String.trim_trailing(line)

    end_match =
      if continuation.start_quote == "\"" do
        Regex.run(@dquoted_multiline_end, trimmed)
      else
        Regex.run(@squoted_multiline_end, trimmed)
      end

    with [_, line_content] <- end_match do
      ret = maybe_stripslashes(continuation, line_content)
      {continuation.name, continuation.value <> ret}
    else
      _ ->
        next_line = maybe_stripslashes(continuation, line)
        next_line = maybe_linefeed(continuation, next_line)

        %Continuation{
          continuation
          | value: continuation.value <> next_line
        }
    end
  end

  @spec parse_multiline_start(String.t(), String.t()) :: Continuation.t()
  defp parse_multiline_start(name, input) do
    {start_quote, rest} = input |> String.trim_leading() |> String.split_at(1)

    continuation = %Continuation{
      name: name,
      value: "",
      start_quote: start_quote
    }

    value = maybe_stripslashes(continuation, rest)
    value = maybe_linefeed(continuation, value)

    %Continuation{continuation | value: value}
  end

  @spec reduce_line([value_pair()], String.t(), Continuation.t() | nil) ::
          {[value_pair()], Continuation.t() | nil}
  defp reduce_line(ret, line, continuation) do
    case parse_line(line, continuation) do
      %Continuation{} = new_continuation ->
        {ret, new_continuation}

      result ->
        {[result | ret], nil}
    end
  end

  @spec remove_comment(String.t()) :: String.t()
  defp remove_comment(val) do
    case String.split(val, "#", parts: 2) do
      [true_val, _comment] -> true_val
      [true_val] -> true_val
    end
  end

  @spec is_comment?(String.t()) :: boolean()
  defp is_comment?(line)
  defp is_comment?("#" <> _rest), do: true
  defp is_comment?(_line), do: false

  @spec is_blank?(String.t()) :: boolean()
  defp is_blank?(line)
  defp is_blank?(""), do: true
  defp is_blank?(_line), do: false

  @spec stripslashes(String.t(), :slash | :no_slash, String.t()) :: String.t()
  defp stripslashes(input, mode \\ :no_slash, acc \\ "")

  defp stripslashes("\\" <> rest, :no_slash, acc) do
    stripslashes(rest, :slash, acc)
  end

  defp stripslashes("", :no_slash, acc), do: acc

  defp stripslashes(input, :no_slash, acc) do
    case String.split(input, "\\", parts: 2) do
      [all] -> acc <> all
      [head, tail] -> stripslashes(tail, :slash, acc <> head)
    end
  end

  defp stripslashes("n" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "\n")
  defp stripslashes("r" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "\r")
  defp stripslashes("t" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "\t")
  defp stripslashes("f" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "\f")
  defp stripslashes("b" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "\b")
  defp stripslashes("\"" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "\"")
  defp stripslashes("'" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "'")
  defp stripslashes("\\" <> rest, :slash, acc), do: stripslashes(rest, :no_slash, acc <> "\\")

  defp stripslashes(<<"u", hex::binary-size(4), rest::binary>>, :slash, acc) do
    with true <- Regex.match?(@hex_re, hex),
         {int, _rest} <- Integer.parse(hex, 16) do
      stripslashes(rest, :no_slash, acc <> <<int::utf8>>)
    else
      _ -> stripslashes(rest, :no_slash, acc <> "\\u" <> hex)
    end
  end

  defp stripslashes(input, :slash, acc), do: stripslashes(input, :no_slash, acc <> "\\")

  @spec maybe_stripslashes(Continuation.t(), String.t()) :: String.t()
  defp maybe_stripslashes(continuation, input)

  defp maybe_stripslashes(%Continuation{start_quote: "\""}, input), do: stripslashes(input)
  defp maybe_stripslashes(_, input), do: input

  @spec maybe_linefeed(Continuation.t(), String.t()) :: String.t()
  defp maybe_linefeed(continuation, input)

  defp maybe_linefeed(%Continuation{start_quote: "\""}, input) do
    if String.ends_with?(input, "\\") do
      String.slice(input, 0..-2//1)
    else
      input <> "\n"
    end
  end

  defp maybe_linefeed(_, input), do: input <> "\n"
end