defmodule Mongo.UrlParser do
  @moduledoc """
    Mongo connection URL parsing util

    [See](https://docs.mongodb.com/manual/reference/connection-string/#connections-connection-options) for the complete list of options.

  """

  require Logger

  @mongo_url_regex ~r/^mongodb(?<srv>\+srv)?:\/\/(?:(?<username>[^:]+):(?<password>[^@]+)@)?(?<seeds>[^\/\?]+)(?:\/(?<database>[^?]*)?(?:\?(?<options>(?:[^\s=]+=[^\s&]*)+))?)?$/

  if Code.ensure_loaded?(:ezstd) do
    @compressors ["zstd", "zlib"]
  else
    @compressors ["zlib"]
  end

  # https://docs.mongodb.com/manual/reference/connection-string/#connections-connection-options
  @mongo_options %{
    # Path options
    "username" => :string,
    "password" => :string,
    "database" => :string,
    # Query options
    "replicaSet" => :string,
    "directConnection" => ["true", "false"],
    "ssl" => ["true", "false"],
    "connectTimeoutMS" => :number,
    "socketTimeoutMS" => :number,
    "maxPoolSize" => :number,
    "minPoolSize" => :number,
    "maxIdleTimeMS" => :number,
    "waitQueueMultiple" => :number,
    "waitQueueTimeoutMS" => :number,
    "w" => :number_or_string,
    "wtimeoutMS" => :number,
    "journal" => ["true", "false"],
    "readConcernLevel" => ["local", "majority", "linearizable", "available"],
    "readPreference" => [
      "primary",
      "primaryPreferred",
      "secondary",
      "secondaryPreferred",
      "nearest"
    ],
    "maxStalenessSeconds" => :number,
    "readPreferenceTags" => :string,
    "authSource" => :string,
    "authMechanism" => ["SCRAM-SHA-1", "MONGODB-CR", "MONGODB-X509", "GSSAPI", "PLAIN"],
    "gssapiServiceName" => :string,
    "localThresholdMS" => :number,
    "serverSelectionTimeoutMS" => :number,
    "serverSelectionTryOnce" => ["true", "false"],
    "heartbeatFrequencyMS" => :number,
    "retryWrites" => ["true", "false"],
    "tls" => ["true", "false"],
    "compressors" => @compressors,
    "uuidRepresentation" => ["standard", "csharpLegacy", "javaLegacy", "pythonLegacy"],
    # Elixir Driver options
    "type" => ["unknown", "single", "replicaSetNoPrimary", "sharded"]
  }

  @driver_option_map %{
    max_pool_size: :pool_size,
    replica_set: :set_name,
    w_timeout: :wtimeout
  }

  defp parse_option_value(_key, ""), do: nil

  defp parse_option_value("compressors", values) do
    values
    |> String.split(",")
    |> Enum.filter(fn compressor -> compressor in @compressors end)
  end

  defp parse_option_value(key, value) do
    case @mongo_options[key] do
      :number ->
        String.to_integer(value)

      :string ->
        value

      :number_or_string ->
        case Integer.parse(value) do
          {num, ""} ->
            num

          _string ->
            value
        end

      enum when is_list(enum) ->
        if Enum.member?(enum, value) do
          value
          |> Macro.underscore()
          |> String.to_atom()
        end

      _other ->
        nil
    end
  end

  defp add_option([key, value], opts), do: add_option({key, value}, opts)

  defp add_option({key, value}, opts) do
    case parse_option_value(key, value) do
      nil ->
        opts

      value ->
        key =
          key
          |> Macro.underscore()
          |> String.to_atom()

        value = decode_percent(key, value)

        Keyword.put_new(opts, @driver_option_map[key] || key, value)
    end
  end

  defp add_option(_other, acc), do: acc

  defp decode_percent(:username, value), do: URI.decode_www_form(value)
  defp decode_percent(:password, value), do: URI.decode_www_form(value)
  defp decode_percent(:auth_source, value), do: URI.decode_www_form(value)
  defp decode_percent(_other, value), do: value

  defp parse_query_options(opts, %{"options" => options}) when is_binary(options) do
    options
    |> String.split("&")
    |> Enum.map(fn option -> String.split(option, "=") end)
    |> Enum.reduce(opts, &add_option/2)
  end

  defp parse_query_options(opts, _frags), do: opts

  defp parse_seeds(opts, %{"seeds" => seeds}) do
    Keyword.put(opts, :seeds, String.split(seeds, ","))
  end

  defp parse_seeds(opts, _frags), do: opts

  defp resolve_srv_url(%{"seeds" => url, "srv" => srv, "options" => orig_options} = frags)
       when is_bitstring(url) and srv == "+srv" do
    # Fix for windows only
    with {:win32, _} <- :os.type() do
      :inet_db.add_ns({4, 2, 2, 1})
    end

    with url_char <- String.to_charlist(url),
         {:ok, {_, _, _, _, _, srv_record}} <-
           :inet_res.getbyname(~c"_mongodb._tcp." ++ url_char, :srv),
         {:ok, host} <- get_host_srv(srv_record),
         {:ok, txt_record} <- resolve_txt_record(url_char),
         txt <- build_params(orig_options, txt_record) do
      frags
      |> Map.put("seeds", host)
      |> Map.put("options", txt)
    else
      err -> err
    end
  end

  defp resolve_srv_url(frags), do: frags

  defp build_params(orig_options, nil) do
    "#{orig_options}&ssl=true"
  end

  defp build_params(orig_options, txt_record) do
    "#{orig_options}&#{txt_record}&ssl=true"
  end

  defp resolve_txt_record(url_char) do
    case :inet_res.lookup(url_char, :in, :txt) do
      [[txt_record] | _] ->
        {:ok, txt_record}

      _other ->
        {:ok, nil}
    end
  end

  @spec get_host_srv([{term, term, term, term}]) :: {:ok, String.t()}
  defp get_host_srv(srv) when is_list(srv) do
    hosts = Enum.map_join(srv, ",", fn {_, _, port, host} -> "#{host}:#{port}" end)

    {:ok, hosts}
  end

  defp hide_password(opts) do
    case Keyword.get(opts, :password) do
      nil ->
        opts

      value ->
        ## start GenServer and put id
        with {:ok, pid} <- Mongo.PasswordSafe.start_link(),
             :ok <- Mongo.PasswordSafe.set_password(pid, value) do
          opts
          |> Keyword.put(:password, "*****")
          |> Keyword.put(:pw_safe, pid)
        end
    end
  end

  @spec parse_url(Keyword.t()) :: Keyword.t()
  def parse_url(opts) when is_list(opts) do
    with {url, opts} when is_binary(url) <- Keyword.pop(opts, :url),
         frags when frags != nil <- Regex.named_captures(@mongo_url_regex, url),
         frags <- resolve_srv_url(frags),
         opts <- parse_seeds(opts, frags),
         opts <- parse_query_options(opts, frags),
         opts <- process_read_preferences(opts),
         # Parse fixed parameters (database, username & password) & merge them with query options
         opts <- Enum.reduce(frags, opts, &add_option/2) do
      opts
    else
      _other -> opts
    end
    |> hide_password()
  end

  def parse_url(opts), do: opts

  defp process_read_preferences(opts) do
    opts =
      case Keyword.get(opts, :read_preference) do
        nil ->
          opts

        mode when is_atom(mode) ->
          read_preference =
            %{mode: mode}
            |> extend_read_preference_tags(opts)
            |> extend_max_staleness_ms(opts)

          Keyword.put(opts, :read_preference, read_preference)

        _other ->
          opts
      end

    Keyword.drop(opts, [:read_preference_tags, :max_staleness_seconds])
  end

  defp extend_read_preference_tags(read_preference, opts) do
    case Keyword.get(opts, :read_preference_tags, []) |> parse_tags() do
      [] ->
        read_preference

      tags ->
        Map.put(read_preference, :tags, Keyword.new(tags))
    end
  end

  defp extend_max_staleness_ms(read_preference, opts) do
    case Keyword.get(opts, :max_staleness_seconds) do
      nil ->
        read_preference

      max_staleness_seconds ->
        Map.put(read_preference, :max_staleness_ms, max_staleness_seconds * 1_000)
    end
  end

  defp parse_tags([]) do
    []
  end

  defp parse_tags(tags) do
    tags
    |> String.split(",")
    |> Enum.map(fn key_value -> to_tuple(key_value) end)
    |> Enum.reject(fn key_value -> key_value == nil end)
  end

  defp to_tuple(key_value) do
    case String.split(key_value, ":") do
      [key, value] ->
        {String.to_atom(key), value}

      _other ->
        Logger.warning("Unable to parse the read preference tags #{inspect(key_value)}")
        nil
    end
  end
end