case update.message.text do
      "/" <> command ->
        reply = command(String.split(command))

    case update do
      %Nadia.Model.Update{message: %Nadia.Model.Message{text: text, chat: chat}} ->
        case text do
          "/" <> command ->
            with {:ok, {reply, opts}} <- command(String.split(command)),
                 {:ok, _} <- Nadia.send_message(chat.id, reply, opts) do
              :ok
            else
              {:error, err} ->
                Logger.error("Error: #{err}")
                :ok
            end

        case Nadia.send_message(update.message.chat.id, reply) do
          {:ok, _} ->

          _ ->

        end

          {:error, err} ->
            Logger.error("Telegram error: #{err}")

      %Nadia.Model.Update{
        callback_query: %Nadia.Model.CallbackQuery{data: data, message: message}
      } ->
        case data do
          "/" <> command ->
            with {:ok, {reply, opts}} <- command(String.split(command)),
                 {:ok, _} <- Nadia.send_message(message.chat.id, reply, opts) do
              :ok
            else
              {:error, err} ->
                Logger.error("Error: #{err}")
                :ok
            end
          _ ->

  defp command([cmd | params]) do
    cmd_with_params(cmd, params)
  end

    DB.random_word()

    word = DB.random_word()
    {:ok,
     {
       word,
       [
         reply_markup: %Nadia.Model.InlineKeyboardMarkup{
           inline_keyboard: [
             [
               %Nadia.Model.InlineKeyboardButton{
                 callback_data: "/usage #{word}",
                 text: "Example"
               }
             ]
           ]
         }
       ]
     }}

  defp cmd_without_params(cmd) do
    Logger.warning("Unknown command #{cmd}")

  defp cmd_without_params(_) do
    {:error, :unknown_command}

  defp cmd_with_params("usage", [word]) do
    sentence = DB.word_sentence(word)
    {:ok, {sentence, []}}
  end
  defp cmd_with_params(_, _) do
    {:error, :unknown_command}
  end

  def word_sentence(word) do
    res =
      Bolt.Sips.query!(
        Bolt.Sips.conn(),
        """
        MATCH (w:Word {word: $word})-[:OF_SENTENCE]-(s:Sentence)
        WITH collect(s) as sentences
        WITH apoc.coll.randomItem(sentences) as sentence
        return sentence.text as text
        """,
        %{word: word}
      )
    [text] = res["text"]
    text
  end