defp confirm_user_multi(user, context \\ "confirm") do

    |> Ecto.Multi.delete_all(:tokens, UserToken.by_user_and_contexts_query(user, [context]))

  @doc ~S"""

  Delivers magic log in link to the given user.

  ## Examples

      iex> deliver_user_magic_log_in(user, &url(~p"/users/log_in/magic/verify/#{&1})")

      {:ok, %{to: ..., body: ...}}

  """

  def deliver_user_magic_log_in(%User{} = user, magic_log_in_url_fun)

      when is_function(magic_log_in_url_fun, 1) do

    {encoded_token, user_token} = UserToken.build_email_token(user, "magic")

    user_token = Repo.insert!(user_token)

    UserNotifier.deliver_magic_log_in(user, magic_log_in_url_fun.(encoded_token))

    user_token

  end

  @doc """

  Verifies a magic log in token and broadcasts it via pubsub.

  """

  @spec magic_log_in_user(String.t()) :: {:ok, User.t()} | :error

  def magic_log_in_user(token) do

    with {:ok, query} <- UserToken.verify_email_token_query(token, "magic"),

         %User{} = user <- Repo.one(query) do

      Phoenix.PubSub.broadcast(MyApp.PubSub, "magic:#{user.session_id}", {:magic_log_in, token})

      {:ok, user}

    else

      _ -> :error

    end

  end

  @doc """

  Verifies a magic log in token and returns the authenticated user. Deletes the token.

  """

  @spec complete_magic_log_in_user(String.t()) :: {:ok, User.t()} | :error

  def complete_magic_log_in_user(token) do

    with {:ok, query} <- UserToken.verify_email_token_query(token, "magic"),

         %User{} = user <- Repo.one(query),

         {:ok, %{user: user}} <- Repo.transaction(confirm_user_multi(user, "magic")) do

      {:ok, user}

    else

      _ -> :error

    end

  end

    field :session_id, :string, virtual: true

  @doc """

  Deliver a magic log in link to a user email.

  """

  def deliver_magic_log_in(user, url) do

    deliver(user.email, "Magic log-in link", """

    ==============================

    Hi #{user.email},

    Log in by visiting the URL below:

    #{url}

    This magic link will log you in on the device you requested it from.

    ==============================

    """)

  end

  @magic_link_validity_in_days 1

            select: user,

            select_merge: %{session_id: token.id}

  defp days_for_context("magic"), do: @magic_link_validity_in_days

  def create(conn, %{"_action" => "magic", "user" => %{"token" => token}}) do

    case Accounts.complete_magic_log_in_user(token) do

      {:ok, user} ->

        conn

        |> put_flash(:info, "Welcome back!")

        |> UserAuth.log_in_user(user)

      :error ->

        conn

        |> put_flash(:error, "Failed to complete magic log-in.")

        |> redirect(to: ~p"/users/log_in/magic")

    end

  end

        <:actions>

          <.link href={~p"/users/log_in/magic"} class="text-sm font-semibold">

            Log in with magic link

          </.link>

        </:actions>

defmodule MyAppWeb.UserMagicLoginLive do

  use MyAppWeb, :live_view

  alias MyApp.Accounts

  def render(assigns) do

    ~H"""

    <div :if={@step == :auth_ready} class="mx-auto max-w-sm">

      <.header class="text-center">

        Log in with magic link

        <:subtitle>

          Enter your email to receive a magic log-in link.

        </:subtitle>

      </.header>

      <.simple_form for={@user_form} id="magic_form" phx-submit="save">

        <.input field={@user_form[:email]} type="email" label="Email" required />

        <:actions>

          <.button phx-disable-with="Submitting..." class="w-full">

            Send a link

          </.button>

        </:actions>

      </.simple_form>

    </div>

    <div :if={@step == :auth_waiting} class="mx-auto max-w-sm">

      <.header class="text-center">

        Waiting...

        <:subtitle>

          If you have a user account with us, you will receive an email with a link to log in.

        </:subtitle>

      </.header>

      <div class="flex justify-center mt-8">

        <.icon

          :if={@token == nil}

          name="hero-envelope"

          class="h-16 w-16 text-zinc-900 animate-bounce"

        />

        <.icon :if={@token != nil} name="hero-envelope-open" class="h-16 w-16 text-zinc-900" />

      </div>

      <.form

        for={@user_form}

        id="verify_form"

        phx-trigger-action={@trigger_submit}

        action={~p"/users/log_in?_action=magic"}

        method="post"

      >

        <input type="hidden" name={@user_form[:token].name} value={@token} />

      </.form>

    </div>

    <div :if={@step == :verify_success} class="mx-auto max-w-sm">

      <.header class="text-center">

        Welcome back, <%= @email %>!

        <:subtitle>

          You've been logged in on the browser where you requested this magic link.

        </:subtitle>

      </.header>

      <div class="flex justify-center mt-8">

        <.icon name="hero-envelope-open" class="h-16 w-16 text-zinc-900" />

      </div>

    </div>

    <div :if={@step == :verify_error} class="mx-auto max-w-sm">

      <.header class="text-center">

        Oops

        <:subtitle>

          Things didn't go as planned, please try again.

        </:subtitle>

      </.header>

      <div class="flex justify-center mt-8">

        <.icon name="hero-x-mark" class="h-16 w-16 text-red-500" />

      </div>

    </div>

    """

  end

  def mount(%{"token" => token}, _session, socket) do

    case Accounts.magic_log_in_user(token) do

      {:ok, user} ->

        {:ok,

         redirect(socket, to: ~p"/users/log_in/magic/verify?success=true&email=#{user.email}")}

      :error ->

        {:ok, redirect(socket, to: ~p"/users/log_in/magic/verify?success=false")}

    end

  end

  def mount(%{"success" => "true"} = params, _session, socket) do

    {:ok, assign(socket, step: :verify_success, email: params["email"])}

  end

  def mount(%{"success" => "false"}, _session, socket) do

    {:ok, assign(socket, step: :verify_error)}

  end

  def mount(_params, _session, socket) do

    {:ok, assign(socket, step: :auth_ready, token: nil)}

  end

  def handle_params(_params, _uri, socket) do

    {:noreply,

     socket

     |> assign(:user_form, to_form(%{}, as: :user))

     |> assign(:trigger_submit, false)}

  end

  def handle_event("save", %{"user" => user_params}, socket) do

    save_user(socket, socket.assigns.live_action, user_params)

  end

  def save_user(socket, :log_in, %{"email" => user_email}) do

    magic_log_in(Accounts.get_user_by_email(user_email), socket)

  end

  def magic_log_in(nil, socket) do

    Process.sleep(Enum.random(500..1500))

    {:noreply, assign(socket, :step, :auth_waiting)}

  end

  def magic_log_in(user, socket) do

    token = Accounts.deliver_user_magic_log_in(user, &url(~p"/users/log_in/magic/verify/#{&1}"))

    Phoenix.PubSub.subscribe(MyApp.PubSub, "magic:#{token.id}")

    {:noreply, assign(socket, :step, :auth_waiting)}

  end

  def handle_info({:magic_log_in, token}, socket) do

    Process.send_after(self(), :trigger_submit, :timer.seconds(1))

    {:noreply, assign(socket, :token, token)}

  end

  def handle_info(:trigger_submit, socket) do

    {:noreply, assign(socket, :trigger_submit, true)}

  end

end

      live "/users/log_in/magic", UserMagicLoginLive, :log_in

      live "/users/log_in/magic/verify/:token", UserMagicLoginLive, :verify

      live "/users/log_in/magic/verify", UserMagicLoginLive, :verify