;;; notmuch-message.el --- message-mode functions specific to notmuch
;;
;; Copyright © Jesse Rosenthal
;;
;; This file is part of Notmuch.
;;
;; Notmuch is free software: you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;;
;; Notmuch is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;; General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with Notmuch.  If not, see <https://www.gnu.org/licenses/>.
;;
;; Authors: Jesse Rosenthal <jrosenthal@jhu.edu>

;;; Code:

(require 'message)
(require 'notmuch-tag)
(require 'notmuch-mua)
(require 'notmuch-maildir-fcc)

(declare-function notmuch-show-get-message-id "notmuch-show" (&optional bare))

(defcustom notmuch-message-replied-tags '("+replied")
  "List of tag changes to apply to a message when it has been replied to.

Tags starting with \"+\" (or not starting with either \"+\" or
\"-\") in the list will be added, and tags starting with \"-\"
will be removed from the message being replied to.

For example, if you wanted to add a \"replied\" tag and remove
the \"inbox\" and \"todo\" tags, you would set:
    (\"+replied\" \"-inbox\" \"-todo\"\)"
  :type '(repeat string)
  :group 'notmuch-send)

(defcustom notmuch-message-draft-tags '("+draft")
  "List of tags changes to apply to a draft message when it is saved in the database.

Tags starting with \"+\" (or not starting with either \"+\" or
\"-\") in the list will be added, and tags starting with \"-\"
will be removed from the message being stored.

For example, if you wanted to give the message a \"draft\" tag
but not the (normally added by default) \"inbox\" tag, you would
set:
    (\"+draft\" \"-inbox\")"
  :type '(repeat string)
  :group 'notmuch-send)

(defcustom notmuch-message-draft-folder "drafts"
  "Folder to save draft messages in.

This should be specified relative to the root of the notmuch
database. It will be created if necessary."
  :type 'string
  :group 'notmuch-send)

(defcustom notmuch-message-quoted-tags '()
  "Mml tags to quote.

This should be a list of mml tags to quote before saving. You do
not need to include \"secure\" as that is handled separately.

If you include \"part\" then attachments will not be saved with
the draft -- if not then they will be saved with the draft. The
former means the attachments may not still exist when you resume
the message, the latter means that the attachments as they were
when you postponed will be sent with the resumed message.

Note you may get strange results if you change this between
postponing and resuming a message."
  :type '(repeat string)
  :group 'notmuch-send)

(defcustom notmuch-message-warn-encryption t
  "Warn if the user postpones or saves a message with an mml encryption tag in it"
  :type 'boolean
  :group 'notmuch-send
  :group 'notmuch-crypto)

(defvar notmuch-message-draft-id nil
  "Message-id of the most recent saved draft of this message")
(make-variable-buffer-local 'notmuch-message-draft-id)

(defun notmuch-message-mark-replied ()
  ;; get the in-reply-to header and parse it for the message id.
  (let ((rep (mail-header-parse-addresses (message-field-value "In-Reply-To"))))
    (when (and notmuch-message-replied-tags rep)
      (notmuch-tag (notmuch-id-to-query (car (car rep)))
	       (notmuch-tag-change-list notmuch-message-replied-tags)))))

(defun notmuch-message-mark-draft-deleted ()
  "Tag the last saved draft deleted.

Used when a new version is saved, or the message is sent."
  (when notmuch-message-draft-id
    (notmuch-tag notmuch-message-draft-id '("+deleted"))))

(defun notmuch-message-quote-some-mml ()
  "Quote the mml tags in `notmuch-message-quoted-tags`."
  (save-excursion
    ;; First we deal with any secure tag separately.
    (message-goto-body)
    (when (looking-at "<#secure[^\n]*>\n")
      (let ((secure-tag (match-string 0)))
	(delete-region (match-beginning 0) (match-end 0))
	(message-add-header (concat "X-Notmuch-Emacs-Secure: " secure-tag))))
  ;; This is copied from mml-quote-region but only quotes the
  ;; specified tags.
  (when notmuch-message-quoted-tags
      (let ((re (concat "<#!*/?\\("
			(mapconcat 'identity notmuch-message-quoted-tags "\\|")
			"\\)")))
	(message-goto-body)
	(while (re-search-forward re nil t)
	  ;; Insert ! after the #.
	  (goto-char (+ (match-beginning 0) 2))
	  (insert "!"))))))

(defun notmuch-message-unquote-some-mml ()
  "Unquote the mml tags in `notmuch-message-quoted-tags`."
    (save-excursion
    (when notmuch-message-quoted-tags
      (let ((re (concat "<#!+/?\\("
			(mapconcat 'identity notmuch-message-quoted-tags "\\|")
			"\\)")))
	(message-goto-body)
	(while (re-search-forward re nil t)
	  ;; Remove one ! from after the #.
	  (goto-char (+ (match-beginning 0) 2))
	  (delete-char 1))))
    (let (secure-tag)
      (save-restriction
	(message-narrow-to-headers)
	(setq secure-tag (message-fetch-field "X-Notmuch-Emacs-Secure" 't))
	(message-remove-header "X-Notmuch-Emacs-Secure"))
      (message-goto-body)
      (when secure-tag
	(insert secure-tag "\n")))))

(defun notmuch-message-check-encryption ()
  "Query user if there an mml tag that looks like it might indicate encryption.

Returns t if there is no such tag, or the user confirms they mean
it."
  (save-excursion
    (message-goto-body)
      (or
       ;; We fine if there is no secure tag, and no #part encryption
       (not (re-search-forward "<#\\(part encrypt\\|secure.*mode=.*encrypt>\\)" nil 't))
       ;; The user confirms they means it.
       (yes-or-no-p "\
This message contains mml tags that suggest it is intended to be encrypted.
Really save and index an unencrypted copy?
(Customize `notmuch-message-warn-encrypted' to avoid this warning)"))))

(defun notmuch-message-save-draft ()
  "Save the current draft message in the notmuch database.

This saves the current message in the database with tags
`notmuch-message-draft-tags` (in addition to any default tags
applied to newly inserted messages)."
  (interactive)
  (when (and notmuch-message-warn-encryption
	     (not (notmuch-message-check-encryption))
	     (error "Save aborted")))
  (let (;; We need the message id as we need it for tagging. Note
	;; message-make-message-id gives the id inside a "<" ">" pair,
	;; but notmuch doesn't want that form, so remove them.
	(id (concat "draft-" (substring (message-make-message-id) 1 -1))))
    (with-temporary-notmuch-message-buffer
     ;; We insert a Date header and a Message-ID header, the former
     ;; so that it is easier to search for the message, and the
     ;; latter so we have a way of accessing the saved message (for
     ;; example to delete it at a later time). We check that the
     ;; user has these in `message-deletable-headers` (the default)
     ;; as otherwise they are doing something strange and we
     ;; shouldn't interfere. Note, since we are doing this in a new
     ;; buffer we don't change the version in the compose buffer.
     (if (member 'Message-ID message-deletable-headers)
	 (progn
	   (message-remove-header "Message-ID")
	   (message-add-header (concat "Message-ID: <" id ">")))
       (message "You have customized emacs so Message-ID is not a deletable header, so not changing it")
       (setq id nil))
     (if (member 'Date message-deletable-headers)
	 (progn
	   (message-remove-header "Date")
	   (message-add-header (concat "Date: " (message-make-date))))
       (message "You have customized emacs so Date is not a deletable header, so not changing it"))
     (message-add-header "X-Notmuch-Emacs-Draft: True")
     (notmuch-message-quote-some-mml)
     (notmuch-maildir-setup-message-for-saving)
     (notmuch-maildir-notmuch-insert-current-buffer
      notmuch-message-draft-folder 't notmuch-message-draft-tags))
    ;; We are now back in the original compose buffer. Note the
    ;; function notmuch-call-notmuch-process (called by
    ;; notmuch-maildir-notmuch-insert-current-buffer) signals an error
    ;; on failure, so to get to this point it must have
    ;; succeeded. Also, notmuch-message-draft-id is still the id of the
    ;; previous draft, so it is safe to mark it deleted.
    (notmuch-message-mark-draft-deleted)
    (setq notmuch-message-draft-id (concat "id:" id))
    (set-buffer-modified-p nil)))

(defun notmuch-message-postpone ()
  "Save the draft message in the notmuch database and exit buffer."
  (interactive)
  (notmuch-message-save-draft)
  (kill-buffer))

(defun notmuch-message-resume (id)
  "Resume editing of message with id ID."
  (let* ((tags (process-lines notmuch-command "search" "--output=tags"
			      "--exclude=false" id))
	 (draft (equal tags (notmuch-update-tags tags notmuch-message-draft-tags))))
    (when (or draft
	      (yes-or-no-p "Message does not appear to be a draft: really resume? "))
      (switch-to-buffer (get-buffer-create (concat "*notmuch-draft-" id "*")))
      (setq buffer-read-only nil)
      (erase-buffer)
      (let ((coding-system-for-read 'no-conversion))
	(call-process notmuch-command nil t nil "show" "--format=raw" id))
      (mime-to-mml)
      (goto-char (point-min))
      (when (re-search-forward "^$" nil t)
	(replace-match mail-header-separator t t))
      ;; Remove the Date and Message-ID headers (unless the user has
      ;; explicitly customized emacs to tell us not to) as they will
      ;; be replaced when the message is sent.
      (save-restriction
	(message-narrow-to-headers)
	(when (member 'Message-ID message-deletable-headers)
	  (message-remove-header "Message-ID"))
	(when (member 'Date message-deletable-headers)
	  (message-remove-header "Date"))
	;; The X-Notmuch-Emacs-Draft header is a more reliable
	;; indication of whether the message really is a draft.
	(setq draft (> (message-remove-header "X-Notmuch-Emacs-Draft") 0)))
      ;; If the message is not a draft we should not unquote any mml.
      (when draft
	(notmuch-message-unquote-some-mml))
      (notmuch-message-mode)
      (set-buffer-modified-p nil)
      ;; If the resumed message was a draft then set the draft
      ;; message-id so that we can delete the current saved draft if the
      ;; message is resaved or sent.
      (setq notmuch-message-draft-id (when draft id)))))


(add-hook 'message-send-hook 'notmuch-message-mark-replied)
(add-hook 'message-send-hook 'notmuch-message-mark-draft-deleted)

(provide 'notmuch-message)

;;; notmuch-message.el ends here