;;; -*- lexical-binding: t -*-

;; ---------------- rekado minor mode --------------------
(defvar rekado-permanent-mode-q nil "indicates whether permanent keys are active")
(defvar rekado-mode-map (make-sparse-keymap) "keymap for rekado-mode")
(defun rekado-mode-define-keys (define-permanent-keys)
  "Defines key bindings for rekado-mode.  If the argument is t,
the edit mode keys will be bound as well."

  ;; return a command that will enable transient-mark-mode if it isn't
  ;; yet active before running the command `cmd`
  (cl-labels ((transient-wrap (cmd)
                              (lambda ()
                                (interactive)
                                (unless (and transient-mark-mode mark-active)
                                  (set-mark-command nil)
                                  (setq transient-mark-mode '(only . ,transient-mark-mode)))
                                (funcall cmd))))
    (let* ((modal-keys
            `(("a" . move-beginning-of-line)
              ("e" . move-end-of-line)

              ;; jump to character
              ("f" . ace-jump-char-mode)
              ("i" . rekado-permanent-mode-exit)
              ;; undo as in vim
              ("u" . undo)
              ;; repeat as in vim
              ("." . repeat)
              ;; paste as in vim
              ("p" . (lambda ()
                       (interactive)
                       (next-line)
                       (beginning-of-line)
                       (yank)))
              ("P" . (lambda ()
                       (interactive)
                       (beginning-of-line)
                       (yank)))
              ;; open line below/above as in vim
              ("o" . (lambda ()
                       (interactive)
                       (open-line-below)
                       (rekado-permanent-mode-exit)))
              ("O" . (lambda ()
                       (interactive)
                       (open-line-above)
                       (rekado-permanent-mode-exit)))
              ;; join lines (like J in vim)
              ("j" . (lambda ()
                       (interactive)
                       (join-line -1)))
              ;; change till the end of the line
              ("R" . (lambda ()
                       (interactive)
                       (kill-line)
                       (rekado-permanent-mode-exit)))
              )))
      (progn
        ;; toggle permanent mode
        (define-key rekado-mode-map
          (kbd "<C-return>")
          'rekado-permanent-mode-toggle)

        ;; toggle permanent mode
        (define-key rekado-mode-map
          (kbd "<M-SPC>")
          'rekado-permanent-mode-toggle)

        (if define-permanent-keys
            ;; define permanent keys
            (progn
              (setq rekado-permanent-mode-q t)
              (mapc (lambda (pair)
                      (define-key rekado-mode-map
                        (kbd (car pair))
                        (cdr pair)))
                    modal-keys))
          ;; undefine permanent keys
          (progn
            (setq rekado-permanent-mode-q nil)
            (mapc (lambda (pair)
                    (define-key rekado-mode-map
                      (kbd (car pair))
                      nil))
                  modal-keys))))))
  rekado-mode-map)

(defun open-line-below ()
  (interactive)
  (end-of-line)
  (newline)
  (indent-for-tab-command))

(defun open-line-above ()
  (interactive)
  (beginning-of-line)
  (newline)
  (forward-line -1)
  (indent-for-tab-command))

(defun rekado-permanent-mode-exit ()
  (interactive)
  (set-cursor-color "White")
  (rekado-mode-define-keys nil))

(defun rekado-permanent-mode-toggle ()
  (interactive)
  (if rekado-permanent-mode-q
      (rekado-permanent-mode-exit)
    (progn
      (set-cursor-color "Red")
      (rekado-mode-define-keys 1))))

;; disable permanent keys when in the minibuffer (also when running
;; commands such as isearch)
(add-hook 'post-command-hook (lambda () (if (minibufferp) (rekado-permanent-mode-exit))))

(define-minor-mode rekado-mode
  "Cursor movement shortcuts while Alt is hold and editing
shortcuts when permanent mode is active."
  :lighter " rekado"
  :global t
  :keymap rekado-mode-map
  :after-hook (rekado-mode-define-keys nil))

(provide 'rekado-mode)