defmodule Microwaveprop.DataCase do
  @moduledoc """
  Test case template for tests that need database access.

  You may define functions here to be used as helpers in
  your tests.

  Finally, if the test case interacts with the database,
  we enable the SQL sandbox, so changes done to the database
  are reverted at the end of every test. If you are using
  PostgreSQL, you can even run database tests asynchronously
  by setting `use Microwaveprop.DataCase, async: true`, although
  this option is not recommended for other databases.
  """

  use ExUnit.CaseTemplate

  alias Ecto.Adapters.SQL.Sandbox

  using do
    quote do
      import Ecto
      import Ecto.Changeset
      import Ecto.Query
      import Microwaveprop.DataCase

      alias Microwaveprop.Repo
    end
  end

  setup tags do
    Microwaveprop.DataCase.setup_sandbox(tags)
    Microwaveprop.DataCase.reset_score_files()
    Microwaveprop.DataCase.stub_nexrad_default()

    # sync tests (async: false) need shared Req.Test mode so stubs
    # are visible to Tasks spawned by async_stream_nolink.
    Req.Test.set_req_test_from_context(tags)

    :ok
  end

  @doc """
  Installs a default 404 stub for the IEM NEXRAD client so tests that
  trigger `CommonVolumeRadarWorker` via `enqueue_for_contact/1` don't
  crash for lack of a Req.Test plug. Individual tests can override with
  their own `Req.Test.stub/2`.
  """
  @spec stub_nexrad_default :: :ok
  def stub_nexrad_default do
    Req.Test.stub(Microwaveprop.Weather.NexradClient, fn conn ->
      Plug.Conn.send_resp(conn, 404, "not found")
    end)
  end

  @doc """
  Sets up the sandbox based on the test tags. Returns the owner pid so
  callers (e.g. `MicrowavepropWeb.ConnCase`) can build Ecto Sandbox
  metadata for out-of-process access (LiveView's connected mount).
  """
  @spec setup_sandbox(map()) :: pid()
  def setup_sandbox(tags) do
    shared? = not tags[:async]
    pid = Sandbox.start_owner!(Microwaveprop.Repo, shared: shared?)

    on_exit(fn ->
      Sandbox.stop_owner(pid)

      # Ecto reverts the pool to :manual mode when a `{:shared, pid}`
      # owner terminates (see Ecto.Adapters.SQL.Sandbox docs). Since
      # test_helper.exs relies on global :auto mode so Oban's
      # background plugins (Stager, Peers, Met.Reporter) can
      # auto-checkout, every `async: false` test permanently flips the
      # pool to :manual once it exits — starving those processes of
      # connections and crash-looping Oban until it exceeds its
      # restart intensity and takes the whole app (and Repo) down with
      # it. Restore :auto after any shared owner exits.
      if shared?, do: Sandbox.mode(Microwaveprop.Repo, :auto)
    end)

    pid
  end

  @doc """
  Wipe the propagation ScoresFile tree between tests so files don't
  leak between cases sharing the same tmp dir.
  """
  @spec reset_score_files :: :ok
  def reset_score_files do
    dir = Application.get_env(:microwaveprop, :propagation_scores_dir)

    if is_binary(dir) do
      File.rm_rf(dir)
    end
  end

  @doc """
  A helper that transforms changeset errors into a map of messages.

      assert {:error, changeset} = Accounts.create_user(%{password: "short"})
      assert "password is too short" in errors_on(changeset).password
      assert %{password: ["password is too short"]} = errors_on(changeset)

  """
  @spec errors_on(Ecto.Changeset.t()) :: map()
  def errors_on(changeset) do
    Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
      Regex.replace(~r"%{(\w+)}", message, fn _, key ->
        opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
      end)
    end)
  end
end