defmodule GlificWeb.API.V1.RegistrationController do
  @moduledoc """
  The Pow User Registration Controller
  """
  @dialyzer {:no_return, reset_password: 2}
  @dialyzer {:no_return, reset_user_password: 2}

  use GlificWeb, :controller

  alias Ecto.Changeset
  alias PasswordlessAuth
  alias Plug.Conn

  alias GlificWeb.{
    APIAuthPlug,
    ErrorHelpers
  }

  alias Glific.{
    Contacts,
    Contacts.Contact,
    Partners,
    Repo,
    Tags,
    Users,
    Users.User
  }

  @doc false
  @spec create(Conn.t(), map()) :: Conn.t()
  def create(conn, %{"user" => user_params}) do
    with {:ok, _message} <- verify_otp(user_params["phone"], user_params["otp"]),
         {:ok, response_data} <- create_user(conn, user_params) do
      json(conn, response_data)
    else
      {:error, errors} ->
        conn
        |> put_status(500)
        |> json(%{error: %{status: 500, message: "Couldn't create user", errors: errors}})
    end
  end

  @spec verify_otp(String.t(), String.t()) :: {:ok, String.t()} | {:error, []}
  defp verify_otp(phone, otp) do
    case PasswordlessAuth.verify_code(phone, otp) do
      :ok ->
        # Remove otp code
        PasswordlessAuth.remove_code(phone)
        {:ok, "verified"}

      {:error, error} ->
        # Error response options: :attempt_blocked | :code_expired | :does_not_exist | :incorrect_code
        {:error, [Atom.to_string(error)]}
    end
  end

  @spec create_user(Conn.t(), map()) :: {:ok, map()} | {:error, []}
  defp create_user(conn, user_params) do
    organization_id = conn.assigns[:organization_id]

    {:ok, contact} =
      Repo.fetch_by(Contact, %{phone: user_params["phone"], organization_id: organization_id})

    updated_user_params =
      user_params
      |> Map.merge(%{
        "password_confirmation" => user_params["password"],
        "contact_id" => contact.id,
        "organization_id" => organization_id,
        "language_id" => contact.language_id
      })

    conn
    |> Pow.Plug.create_user(updated_user_params)
    |> case do
      {:ok, user, conn} ->
        {:ok, _} =
          user
          |> Users.promote_first_user()
          |> add_staff_tag_to_user_contact()

        response_data = %{
          data: %{
            access_token: conn.private[:api_access_token],
            token_expiry_time: conn.private[:api_token_expiry_time],
            renewal_token: conn.private[:api_renewal_token]
          }
        }

        {:ok, response_data}

      {:error, changeset, _conn} ->
        errors = Changeset.traverse_errors(changeset, &ErrorHelpers.translate_error/1)

        {:error, errors}
    end
  end

  @doc false
  @spec add_staff_tag_to_user_contact(User.t()) :: {:ok, String.t()}
  defp add_staff_tag_to_user_contact(user) do
    with {:ok, contact} <-
           Repo.fetch_by(Contact, %{phone: user.phone, organization_id: user.organization_id}),
         {:ok, tag} <-
           Repo.fetch_by(Tags.Tag, %{label: "Staff", organization_id: user.organization_id}),
         {:ok, _} <-
           Tags.create_contact_tag(%{
             contact_id: contact.id,
             tag_id: tag.id,
             organization_id: user.organization_id
           }),
         do: {:ok, "Staff tag added to the user contact"}
  end

  # we need to give user permissions here so we can retrieve and send messages
  # in some cases
  defp build_context(organization_id) do
    organization = Partners.organization(organization_id)
    Repo.put_current_user(organization.root_user)
  end

  @doc """
  verifying google captcha only when token is passed
  """
  @spec send_otp(Conn.t(), map()) :: Conn.t()
  def send_otp(
        conn,
        %{"user" => %{"token" => token, "registration" => "true", "phone" => phone}} =
          _user_params
      ) do
    case Glific.verify_google_captcha(token) do
      {:ok, "success"} ->
        send_otp(conn, %{"user" => %{"phone" => phone, "registration" => "true"}})

      {:error, error} ->
        send_otp_error(conn, error)
    end
  end

  def send_otp(
        conn,
        %{"user" => %{"phone" => phone, "registration" => registration}} = _user_params
      ) do
    organization_id = conn.assigns[:organization_id]
    build_context(organization_id)

    with {:ok, _contact} <- optin_contact(organization_id, phone),
         {:ok, contact} <- can_send_otp_to_phone?(organization_id, phone),
         true <- send_otp_allowed?(organization_id, phone, registration),
         {:ok, _otp} <- create_and_send_verification_code(contact) do
      json(conn, %{data: %{phone: phone, message: "OTP sent successfully to #{phone}"}})
    else
      _ ->
        send_otp_error(conn, "Cannot send the otp to #{phone}")
    end
  end

  @doc false
  @spec send_otp_error(Conn.t(), String.t()) :: Conn.t()
  defp send_otp_error(conn, msg) do
    conn
    |> put_status(400)
    |> json(%{error: %{status: 400, message: msg}})
  end

  @doc """
  Function for generating verification code and sending otp verification message
  """
  @spec create_and_send_verification_code(Contact.t()) :: {:ok, String.t()}
  def create_and_send_verification_code(contact) do
    code = PasswordlessAuth.generate_code(contact.phone)
    Glific.Messages.create_and_send_otp_verification_message(contact, code)
    {:ok, code}
  end

  # see if we can send an hsm or session message to this contact
  @spec can_send_message_to?(Contact.t()) :: boolean
  defp can_send_message_to?(contact) do
    hsm = Contacts.can_send_message_to?(contact, true)
    session = Contacts.can_send_message_to?(contact, false)
    elem(hsm, 0) == :ok || elem(session, 0) == :ok
  end

  @spec can_send_otp_to_phone?(integer, String.t()) :: {:ok, Contact.t()} | {:error, any} | false
  defp can_send_otp_to_phone?(organization_id, phone) do
    with {:ok, contact} <-
           Repo.fetch_by(Contact, %{phone: phone, organization_id: organization_id}),
         true <- can_send_message_to?(contact),
         do: {:ok, contact}
  end

  @spec send_otp_allowed?(integer, String.t(), String.t()) :: boolean
  defp send_otp_allowed?(organization_id, phone, registration) do
    {result, _} = Repo.fetch_by(User, %{phone: phone, organization_id: organization_id})
    (result == :ok && registration == "false") || (result == :error && registration != "false")
  end

  @doc """
  Controller function for reset password
  It also verifies OTP to authorize the request
  """
  @spec reset_password(Conn.t(), map()) :: Conn.t()
  def reset_password(conn, %{"user" => user_params}) do
    %{"phone" => phone, "otp" => otp} = user_params

    with {:ok, _data} <- verify_otp(phone, otp),
         {:ok, response_data} <- reset_user_password(conn, user_params) do
      json(conn, response_data)
    else
      {:error, _errors} ->
        conn
        |> put_status(500)
        |> json(%{error: %{status: 500, message: "Couldn't update user password"}})
    end
  end

  @spec reset_user_password(Conn.t(), map()) :: {:ok, map()} | {:error, []}
  defp reset_user_password(conn, %{"phone" => phone, "password" => password} = user_params) do
    update_params = %{"password" => password, "password_confirmation" => password}

    {:ok, user} =
      Repo.fetch_by(User, %{phone: phone, organization_id: conn.assigns[:organization_id]})

    user
    |> Users.reset_user_password(update_params)
    |> case do
      {:ok, user} ->
        APIAuthPlug.delete_user_sessions(user, conn)

        # Create new user session
        {:ok, conn} =
          Pow.Plug.authenticate_user(
            conn,
            Map.put(user_params, "organization_id", conn.assigns[:organization_id])
          )

        {:ok,
         %{
           data: %{
             access_token: conn.private[:api_access_token],
             token_expiry_time: conn.private[:api_token_expiry_time],
             renewal_token: conn.private[:api_renewal_token]
           }
         }}

      {:error, _error} ->
        {:error, []}
    end
  end

  @spec optin_contact(non_neg_integer(), String.t()) :: {:ok, map()} | {:error, []}
  defp optin_contact(organization_id, phone) do
    %{
      phone: phone,
      organization_id: organization_id,
      method: "registration"
    }
    |> Contacts.optin_contact()
  end
end