;;; reading.el --- minor mode for reading -*- lexical-binding: t; -*-

;;; Code:

(defgroup reading nil
  "Group for Reading mode customizations."
  :prefix "reading-"
  :group 'convenience)

(defcustom reading-vars '((indicate-empty-lines . nil)
                          (indicate-buffer-boundaries . nil))
  "Alist of variables to set in function `reading-mode'.
The car of each cell is the variable name, and the cdr is the
value to set it to."
  :type '(alist :key-type variable
                :value-type sexp))

(defcustom reading-modes '((display-fill-column-indicator-mode . -1)
                           (blink-cursor-mode . -1))
  "Alist of modes to set in function `reading-mode'.
The car of each cell is the function name, and the cdr is the
value to call it with."
  :type '(alist :key-type function
                :value-type sexp))

;;; Internal

(defvar reading--remembered-template "reading--remembered-%s-value"
  "The template passed to `format' for remembered modes and variables.")

(defun reading--remember (things func)
  "Apply FUNC to THINGS, remembering their previous value for later."
  (declare (indent 1))
  (unless (listp things)
    (setq things (list things)))
  (dolist (thing things)
    (set (make-local-variable
          (intern (format reading--remembered-template thing)))
         (and (boundp thing)
              (symbol-value thing)))
    (funcall func thing)))

(defun reading--recall (things func)
  "Recall previously remembered THINGS by applying FUNC to them.
FUNC should be a function with the signature (THING REMEMBERED-SETTING)."
  (declare (indent 1))
  (unless (listp things)
    (setq things (list things)))
  (dolist (thing things)
    (with-demoted-errors "reading--recall: %S"
      (let ((value (symbol-value
                    (intern
                     (format reading--remembered-template thing)))))
        (funcall func thing value)))))

;;; Mode

;;;###autoload
(define-minor-mode reading-mode
  "A mode for reading."
  :lighter " Read"
  (if reading-mode
      ;; turn on
      (progn
        (reading--remember (mapcar #'car reading-vars)
          (lambda (var)
            (set (make-local-variable var)
                 (cdr (assoc var reading-vars)))))
        (reading--remember (mapcar #'car reading-modes)
          (lambda (mode)
            (funcall mode (cdr (assoc mode reading-modes))))))
    ;; turn off
    (reading--recall (mapcar #'car reading-vars)
      (lambda (var orig-val)
        (set (make-local-variable var) orig-val)))
    (reading--recall (mapcar #'car reading-modes)
      (lambda (mode orig-setting)
        (funcall mode (if orig-setting +1 -1))))))

(provide 'reading)
;;; reading.el ends here