messenger_bot_store

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

  import Ecto.Query, warn: false

  alias MessengerBotStore.Model.{
    Conversation,
    Error,
    MessageReport,
    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(external_id) do
    repo().get_by(User, %{external_id: String.to_integer("#{external_id}")})
  end

  @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)
      ** nil

  """
  def get_conversation(mid), do: repo().get_by(Conversation, %{mid: mid})

  @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!(mid), do: repo().get_by!(Conversation, %{mid: mid})

  @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) and
            c.received_at <= ^watermark,
        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) and
            c.received_at <= ^watermark,
        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 """
  Updates a referral.

  ## Examples

      iex> update_referral(referral, %{field: new_value})
      {:ok, %Referral{}}

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

  """
  def update_referral(%Referral{} = referral, attrs) do
    repo = repo()

    referral
    |> Referral.changeset(attrs)
    |> repo.update()
  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

  @doc """
  Returns the list of message_reports.

  ## Examples

      iex> list_message_reports()
      [%MessageReport{}, ...]

  """
  def list_message_reports do
    repo().all(MessageReport)
  end

  @doc """
  Gets a single message_report.

  Raises `Ecto.NoResultsError` if the Message report does not exist.

  ## Examples

      iex> get_message_report!(123)
      %MessageReport{}

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

  """
  def get_message_report!(id), do: repo().get!(MessageReport, id)

  @doc """
  Creates a message_report.

  ## Examples

      iex> create_message_report(%{field: value})
      {:ok, %MessageReport{}}

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

  """
  def create_message_report(attrs \\ %{}) do
    repo = repo()

    %MessageReport{}
    |> MessageReport.changeset(attrs)
    |> repo.insert()
  end

  @doc """
  Updates a message_report.

  ## Examples

      iex> update_message_report(message_report, %{field: new_value})
      {:ok, %MessageReport{}}

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

  """
  def update_message_report(%MessageReport{} = message_report, attrs) do
    repo = repo()

    message_report
    |> MessageReport.changeset(attrs)
    |> repo.update()
  end

  @doc """
  Deletes a MessageReport.

  ## Examples

      iex> delete_message_report(message_report)
      {:ok, %MessageReport{}}

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

  """
  def delete_message_report(%MessageReport{} = message_report) do
    repo().delete(message_report)
  end

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

  ## Examples

      iex> change_message_report(message_report)
      %Ecto.Changeset{source: %MessageReport{}}

  """
  def change_message_report(%MessageReport{} = message_report) do
    MessageReport.changeset(message_report, %{})
  end

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