defmodule BeetRoundServerWeb.UserController do
  use BeetRoundServerWeb, :controller

  alias BeetRoundServer.Accounts
  alias BeetRoundServer.Accounts.User

  action_fallback BeetRoundServerWeb.FallbackController

  def index(conn, _params) do
    users = Accounts.list_users()
    render(conn, :index, users: users)
  end

  def create(conn, %{"user" => user_params}) do
    case Accounts.register_user(user_params) do
      {:ok, %User{} = user} ->
        send_created_response(conn, user)

      {:error, changeset} ->
        with %User{} = user <- Accounts.get_user_by_email(user_params["email"]) do
          send_already_reported_response(conn, user)
        else
          _ ->
            send_not_acceptable(conn, changeset)
        end

      _ ->
        conn
        |> put_status(:bad_request)
        |> put_resp_header("location", ~p"/api/users")
        |> render(:show, changeset: "Bad request")
    end
  end

  def show(conn, %{"id" => id}) do
    user = Accounts.get_user!(id)
    render(conn, :show, user: user)
  end

  def invite(conn, %{"user" => user_params}) do
    case Accounts.get_user!(user_params["user_id"]) do
      nil ->
        IO.puts("User couldn't be found! Reason:")

      user ->
        user_params = Map.put(user_params, "email", user.email)

        email =
          BeetRoundServer.UserEmail.invite(%{
            name: user_params["name"],
            email: user_params["email"],
            access_url: user_params["access_url"]
          })

        case BeetRoundServer.Mailer.deliver(email) do
          {:ok, data} ->
            IO.puts("Mail sent successfully.")
            IO.inspect(data)
            render(conn, :mail_status, %{status: "Mail sent successfully."})

          {:error, error} ->
            IO.puts("Mail error:")
            IO.inspect(error)
            render(conn, :show, %User{})

            # render(conn, :error, error: error, user: user_params)
        end
    end
  end

  # def update(conn, %{"id" => id, "user" => user_params}) do
  #   user = Accounts.get_user!(id)

  #   with {:ok, %User{} = user} <- Accounts.update_user(user, user_params) do
  #     render(conn, :show, user: user)
  #   end
  # end

  # def delete(conn, %{"id" => id}) do
  #   user = Accounts.get_user!(id)

  #   with {:ok, %User{}} <- Accounts.delete_user(user) do
  #     send_resp(conn, :no_content, "")
  #   end
  # end

  defp send_created_response(conn, %User{} = user) do
    encoded_token = Accounts.create_email_token(user)

    conn
    |> put_status(:created)
    |> put_resp_header("location", ~p"/api/users/#{user}")
    |> render(:show, %{user: user, token: encoded_token})
  end

  defp send_already_reported_response(conn, %User{} = user) do
    encoded_token = Accounts.create_email_token(user)
    IO.puts("encoded_token for user: " <> user.email)
    IO.inspect(encoded_token)

    conn
    |> put_status(:already_reported)
    |> render(:show, %{user: user, token: encoded_token})
  end

  defp send_not_acceptable(conn, changeset) do
    conn
    |> put_status(:not_acceptable)
    |> put_resp_header("location", ~p"/api/users")
    |> render(:show, changeset: changeset)
  end
end