defmodule MessengerBotStore do
  @moduledoc """
  The Model context.
  """

  import Ecto.Query, warn: false
  alias MessengerBotStore.Model.{Conversation, Error, Referral, User}

  @app :messenger_bot_store

  @doc """
  Returns the list of users.

  ## Examples

      iex> list_users()
      [%User{}, ...]

  """
  def list_users do
    repo().all(User)
  end

  @doc """
  Gets a single user.

  Raises `Ecto.NoResultsError` if the User does not exist.

  ## Examples

      iex> get_user!(123)
      %User{}

      iex> get_user!(456)
      ** (Ecto.NoResultsError)

  """
  def get_user(id), do: repo().get(User, String.to_integer("#{id}"))

  @doc """
  Creates a user.

  ## Examples

      iex> create_user(%{field: value})
      {:ok, %User{}}

      iex> create_user(%{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def create_user(attrs \\ %{}) do
    repo = repo()
    %User{}
    |> User.changeset(attrs)
    |> repo.insert()
  end

  @doc """
  Updates a user.

  ## Examples

      iex> update_user(user, %{field: new_value})
      {:ok, %User{}}

      iex> update_user(user, %{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def update_user(%User{} = user, attrs) do
    repo = repo()
    user
    |> User.changeset(attrs)
    |> repo.update()
  end

  @doc """
  Deletes a User.

  ## Examples

      iex> delete_user(user)
      {:ok, %User{}}

      iex> delete_user(user)
      {:error, %Ecto.Changeset{}}

  """
  def delete_user(%User{} = user) do
    repo().delete(user)
  end

  @doc """
  Returns an `%Ecto.Changeset{}` for tracking user changes.

  ## Examples

      iex> change_user(user)
      %Ecto.Changeset{source: %User{}}

  """
  def change_user(%User{} = user) do
    User.changeset(user, %{})
  end

  @doc """
  Returns the list of conversations.

  ## Examples

      iex> list_conversations()
      [%Conversation{}, ...]

  """
  def list_conversations do
    repo().all(Conversation)
  end

  @doc """
  Gets a single conversation.

  Raises `Ecto.NoResultsError` if the Conversation does not exist.

  ## Examples

      iex> get_conversation!(123)
      %Conversation{}

      iex> get_conversation!(456)
      ** (Ecto.NoResultsError)

  """
  def get_conversation!(id), do: repo().get!(Conversation, id)

  @doc """
  Creates a conversation.

  ## Examples

      iex> create_conversation(%{field: value})
      {:ok, %Conversation{}}

      iex> create_conversation(%{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def create_conversation(attrs \\ %{}) do
    repo = repo()
    %Conversation{}
    |> Conversation.changeset(attrs)
    |> repo.insert()
  end

  @doc """
  Updates a conversation.

  ## Examples

      iex> update_conversation(conversation, %{field: new_value})
      {:ok, %Conversation{}}

      iex> update_conversation(conversation, %{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def update_conversation(%Conversation{} = conversation, attrs) do
    repo = repo()
    conversation
    |> Conversation.changeset(attrs)
    |> repo.update()
  end

  @doc """
  Updates read_at column of user's conversations.
  """
  def update_conversation_read_at(%{user_id: user_id,
    watermark: watermark}) do
    query =
      from c in Conversation,
        where: c.user_id == ^user_id and is_nil(c.read_at),
        update: [set: [read_at: ^watermark]]
    repo().update_all(query, [])
  end

  @doc """
  Updates delivered_at column of user's conversations.
  """
  def update_conversation_delivered_at(%{user_id: user_id,
    watermark: watermark}) do
    query =
      from c in Conversation,
        where: c.user_id == ^user_id and is_nil(c.delivered_at),
        update: [set: [delivered_at: ^watermark]]
    repo().update_all(query, [])
  end

  @doc """
  Deletes a Conversation.

  ## Examples

      iex> delete_conversation(conversation)
      {:ok, %Conversation{}}

      iex> delete_conversation(conversation)
      {:error, %Ecto.Changeset{}}

  """
  def delete_conversation(%Conversation{} = conversation) do
    repo().delete(conversation)
  end

  @doc """
  Returns an `%Ecto.Changeset{}` for tracking conversation changes.

  ## Examples

      iex> change_conversation(conversation)
      %Ecto.Changeset{source: %Conversation{}}

  """
  def change_conversation(%Conversation{} = conversation) do
    Conversation.changeset(conversation, %{})
  end

  @doc """
  Returns the list of errors.

  ## Examples

      iex> list_errors()
      [%Error{}, ...]

  """
  def list_errors do
    repo().all(Error)
  end

  @doc """
  Gets a single error.

  Raises `Ecto.NoResultsError` if the Error does not exist.

  ## Examples

      iex> get_error!(123)
      %Error{}

      iex> get_error!(456)
      ** (Ecto.NoResultsError)

  """
  def get_error!(id), do: repo().get!(Error, id)

  @doc """
  Creates a error.

  ## Examples

      iex> create_error(%{field: value})
      {:ok, %Error{}}

      iex> create_error(%{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def create_error(attrs \\ %{}) do
    repo = repo()
    %Error{}
    |> Error.changeset(attrs)
    |> repo.insert()
  end

  @doc """
  Updates a error.

  ## Examples

      iex> update_error(error, %{field: new_value})
      {:ok, %Error{}}

      iex> update_error(error, %{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def update_error(%Error{} = error, attrs) do
    repo = repo()
    error
    |> Error.changeset(attrs)
    |> repo.update()
  end

  @doc """
  Deletes a Error.

  ## Examples

      iex> delete_error(error)
      {:ok, %Error{}}

      iex> delete_error(error)
      {:error, %Ecto.Changeset{}}

  """
  def delete_error(%Error{} = error) do
    repo().delete(error)
  end

  @doc """
  Returns an `%Ecto.Changeset{}` for tracking error changes.

  ## Examples

      iex> change_error(error)
      %Ecto.Changeset{source: %Error{}}

  """
  def change_error(%Error{} = error) do
    Error.changeset(error, %{})
  end

  @doc """
  Returns the list of referrals.

  ## Examples

      iex> list_referrals()
      [%Referral{}, ...]

  """
  def list_referrals do
    repo().all(Referral)
  end

  @doc """
  Gets a single referral.

  Raises `Ecto.NoResultsError` if the Referral does not exist.

  ## Examples

      iex> get_referral!(123)
      %Referral{}

      iex> get_referral!(456)
      ** (Ecto.NoResultsError)

  """
  def get_referral!(id), do: repo().get!(Referral, id)

  @doc """
  Creates a referral.

  ## Examples

      iex> create_referral(%{field: value})
      {:ok, %Referral{}}

      iex> create_referral(%{field: bad_value})
      {:error, %Ecto.Changeset{}}

  """
  def create_referral(attrs \\ %{}) do
    repo = repo()
    %Referral{}
    |> Referral.changeset(attrs)
    |> repo.insert()
  end

  @doc """
  Deletes a Referral.

  ## Examples

      iex> delete_referral(referral)
      {:ok, %Referral{}}

      iex> delete_referral(referral)
      {:error, %Ecto.Changeset{}}

  """
  def delete_referral(%Referral{} = referral) do
    repo().delete(referral)
  end

  @doc """
  Returns an `%Ecto.Changeset{}` for tracking referral changes.

  ## Examples

      iex> change_referral(referral)
      %Ecto.Changeset{source: %Referral{}}

  """
  def change_referral(%Referral{} = referral) do
    Referral.changeset(referral, %{})
  end

  defp repo do
    Application.get_env(@app, :repo, MessengerBotStore.Repo)
  end
end