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

;;; Preamble
(setq user-full-name    "Thomas Voss")
(setq user-mail-address "mail@thomasvoss.com")

(when (< emacs-major-version 29)
  (error "Emacs 29 or newer is required"))

(when (featurep 'native-compile)
  (setq
   native-comp-async-report-warnings-errors nil
   native-comp-verbose 0
   native-comp-debug 0
   native-comp-jit-compilation t))

(require 'package)
(custom-set-variables
 '(package-archives '(("gnu"    . "http://elpa.gnu.org/packages/")
                      ("nongnu" . "https://elpa.nongnu.org/nongnu/")
                      ("melpa"  . "http://melpa.org/packages/")))
 '(package-user-dir (expand-file-name "pkg" x-data-directory)))
(package-initialize)

(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(eval-and-compile
  (custom-set-variables
   '(use-package-always-defer t)
   '(use-package-always-ensure t)
   '(use-package-expand-minimally t)))

(eval-when-compile
  (require 'use-package))

;;; Convenience Macros and -Functions
(defmacro λ (&rest body)
  "Convenience macro to create lambda functions that take no arguments
with much shorter and concise syntax.  Calling ‘λ’ with BODY is
equivalent to calling ‘lambda’ with an empty argument list and BODY."
  (declare (pure t) (side-effect-free t))
  `(lambda () ,@body))

(defmacro λi (&rest body)
  "Convenience macro to create interactive lambda functions that take
no arguments with much shorter and concise syntax.  Calling ‘λi’ with
BODY is equivalent to calling ‘lambda’ with an empty argument list and
BODY directly after ‘(interactive)’."
  (declare (pure t) (side-effect-free t))
  `(lambda () (interactive) ,@body))

(defun x-mode-to-hook (mode)
  "Get the hook corresponding to MODE."
  (declare (pure t) (side-effect-free t))
  (intern (concat (symbol-name mode) "-hook")))

(defun x-mode-to-ts-mode (mode)
  "Get the tree-sitter mode corresponding to MODE."
  (declare (pure t) (side-effect-free t))
  (intern (concat
           (string-remove-suffix "-mode" (symbol-name mode))
           "-ts-mode")))

(defun x-do-and-center (function &rest arguments)
  "Call FUNCTION with ARGUMENTS and then center the screen."
  (apply function arguments)
  (recenter))

;;; Rational Defaults
(prefer-coding-system 'utf-8)
(customize-set-variable
 'save-interprogram-paste-before-kill t)

(savehist-mode)
(global-hl-line-mode)

(fset #'yes-or-no-p #'y-or-n-p)
(dolist (mode #'(blink-cursor-mode
                 menu-bar-mode
                 scroll-bar-mode
                 show-paren-mode
                 tool-bar-mode
                 tooltip-mode))
  (apply mode '(-1)))

(custom-set-variables
 '(large-file-warning-threshold nil)
 '(vc-follow-symlinks t)
 '(ad-redefinition-action 'accept))

(custom-set-variables
 '(mouse-wheel-scroll-amount '(1 ((shift) . 1)))
 '(mouse-wheel-progressive-speed nil)
 '(mouse-wheel-follow-mouse t)
 '(scroll-step 1))
(pixel-scroll-precision-mode)

(customize-set-value 'show-paren-delay 0)
(dolist (hook '(conf-mode-hook prog-mode-hook))
  (add-hook hook #'show-paren-local-mode))

(customize-set-value
 'read-extended-command-predicate
 #'command-completion-default-include-p)

(setq-default display-line-numbers 'relative)
(line-number-mode)
(column-number-mode)

;; Backup settings
(custom-set-variables
 '(delete-old-versions t)
 '(version-control t)
 '(kept-new-versions 2)
 '(kept-old-versions 2))

(setq-default fill-column 73)
(add-hook 'text-mode-hook #'auto-fill-mode)

(require 'autorevert)
(customize-set-variable
 'global-auto-revert-non-file-buffers t)
(global-auto-revert-mode)

(customize-set-variable
 'custom-file (expand-file-name
               (format "emacs-custom-%s.el" (user-uid))
               temporary-file-directory))
(load custom-file 'noerror)

(define-key global-map [remap backward-delete-char-untabify]
            #'backward-delete-char)

;;; Documentation Improvements
(use-package helpful
  :bind
  (("C-c h f" . #'helpful-callable)
   ("C-c h v" . #'helpful-variable)
   ("C-c h k" . #'helpful-key)
   ("C-c h o" . #'helpful-symbol)
   ("C-c h p" . #'helpful-at-point)))

;;; Vim Emulation
(use-package evil
  :bind
  (:map evil-normal-state-map
    ("g a" . #'x-evil-align-regexp)
    ("g c" . #'x-evil-comment-or-uncomment-region)
    ("g s" . #'x-evil-sort-lines)
    ("C-h" . #'evil-window-left)
    ("C-j" . #'evil-window-down)
    ("C-k" . #'evil-window-up)
    ("C-l" . #'evil-window-right))
  :init
  (setq ;; All of the following must be set before loading ‘evil-mode’
   evil-want-Y-yank-to-eol t
   evil-v$-excludes-newline t
   evil-respect-visual-line-mode t
   evil-split-window-below t
   evil-vsplit-window-right t
   evil-want-fine-undo t
   evil-undo-system #'undo-redo
   evil-flash-delay 1
   evil-want-keybinding nil)
  (evil-mode)
  (global-visual-line-mode)
  :config
  (evil-set-leader nil (kbd "SPC"))
  (evil-set-leader nil (kbd ",") 'localleader)
  (dolist (mode '(normal visual))
    (evil-global-set-key mode (kbd "C-u") (λi (x-do-and-center #'evil-scroll-up 0)))
    (evil-global-set-key mode (kbd "C-d") (λi (x-do-and-center #'evil-scroll-down 0)))
    (evil-global-set-key mode (kbd "C-v") #'evil-visual-line)
    (evil-global-set-key mode (kbd "M-v") #'evil-visual-block))

  (evil-define-operator x-evil-align-regexp (start end regexp repeat)
    "Evil operator for ‘align-regexp’."
    :move-point nil
    :restore-point t
    (interactive (let ((range (evil-operator-range)))
           (list (car range)
             (cadr range)
             (concat "\\(\\s-*\\)"
                 (read-string "Align regexp: "))
             (y-or-n-p "Repeat? "))))
    (align-regexp start end regexp 1 1 repeat))

  (evil-define-operator x-evil-comment-or-uncomment-region (start end)
    "Evil operator for ‘comment-or-uncomment-region’."
    :move-point nil
    :restore-point t
    (comment-or-uncomment-region start end))

  (evil-define-operator x-evil-sort-lines (start end)
    "Evil operator for ‘sort-lines’."
    :move-point nil
    :restore-point t
    (sort-lines nil start end)))

(defun x-evil-surround-mode-if-evil-mode ()
  (global-evil-surround-mode (unless (evil-mode) -1)))

(use-package evil-surround
  :after evil
  :hook (evil-mode . x-evil-surround-mode-if-evil-mode)
  :init
  (x-evil-surround-mode-if-evil-mode)
  ;; (global-evil-surround-mode)
  :config
  (defmacro x-evil-define-and-bind-quoted-text-object (name key start-regexp end-regexp)
    (let ((inner-name (make-symbol (concat "evil-inner-" name)))
      (outer-name (make-symbol (concat "evil-a-"     name))))
      `(progn
     (evil-define-text-object ,inner-name (count &optional beg end type)
       (evil-select-paren ,start-regexp ,end-regexp beg end type count nil))
     (evil-define-text-object ,outer-name (count &optional beg end type)
       (evil-select-paren ,start-regexp ,end-regexp beg end type count 'inclusive))
     (define-key evil-inner-text-objects-map ,key #',inner-name)
     (define-key evil-outer-text-objects-map ,key #',outer-name))))

  (x-evil-define-and-bind-quoted-text-object "single-quote-open"  "‘" "‘" "’")
  (x-evil-define-and-bind-quoted-text-object "single-quote-close" "’" "‘" "’")
  (x-evil-define-and-bind-quoted-text-object "double-quote-open"  "“" "“" "”")
  (x-evil-define-and-bind-quoted-text-object "double-quote-open"  "“" "“" "”")

  (defun x-evil-surround-function ()
    "Read a function name from the minibuffer and index the list with
the selection.  This is nearly identical to ‘evil-surround-function’
except it provides a useful prompt, and is language-aware."
    (let ((list-name (or (evil-surround-read-from-minibuffer "Function name: ")
             "")))
      (if (derived-mode-p 'lisp-mode 'common-lisp-mode 'emacs-lisp-mode)
      (cons (format "(%s " list-name) ")")
    (cons (format "%s(" (or list-name "")) ")"))))

  (defun x-evil-surround-list ()
    "Read a list name from the minibuffer and index the list with the
selection."
    (let ((list-name (evil-surround-read-from-minibuffer "List name: ")))
      (cons (format "%s[" (or list-name "")) "]")))

  (setq-default
   evil-surround-pairs-alist
   (append
    '((?‘ . ("‘ " . " ’"))
      (?’ . ("‘"  .  "’"))
      (?“ . ("“ " . " ”"))
      (?“ . ("“"  .  "”"))
      (?f . x-evil-surround-function)
      (?l . x-evil-surround-list))
    evil-surround-pairs-alist)))

(use-package evil-collection
  :after evil
  :init
  (evil-collection-init))

;;; Force Spaces For Alighment
(defun x-align-with-spaces (function &rest arguments)
  "Advice to force a given function to align using spaces instead of
tabs, regardless of the value of ‘indent-tabs-mode’."
  (let (indent-tabs-mode)
    (apply function arguments)))

(dolist (f #'(align-regexp c-backslash-region))
  (advice-add f :around #'x-align-with-spaces))

;;; Minibuffer Improvements
(use-package vertico
  :bind
  (:map vertico-map
    ("C-j" . vertico-next)
    ("C-k" . vertico-previous)
    ("C-l" . vertico-insert)
    :map minibuffer-local-map
    ("C-h" . x-minibuffer-backward-kill))
  :custom
  (vertico-cycle t)
  :init
  (vertico-mode)
  :config
  (defun x-minibuffer-backward-kill (arg)
    "When minibuffer completing a filename, delete up to the parent
folder, otherwise delete a word."
    (interactive "p")
    (if minibuffer-completing-file-name
    (if (string-match-p "/." (minibuffer-contents))
        (zap-up-to-char (- arg) ?/)
      (delete-minibuffer-contents))
      (backward-kill-word arg))))

(use-package marginalia
  :after vertico
  :init
  (marginalia-mode))

(use-package orderless
  :custom
  (completion-styles '(orderless basic))
  (orderless-matching-styles '(orderless-prefixes))
  (completion-category-overrides '((file (styles basic partial-completion)))))

;;; Completions
;; Disable corfu for now (it’s causing Emacs to crash)
;; (use-package corfu
;;   :hook ((prog-mode . corfu-mode))
;;   :custom
;;   (corfu-auto t)
;;   (corfu-cycle t)
;;   (corfu-auto-prefix 1)
;;   (corfu-auto-delay 0))
(defun x-company-require-prefix (candidates)
  "Transformer for ‘company-mode’ that requires that all candidates begin with
‘company-prefix’."
  (seq-filter (lambda (s) (string-prefix-p company-prefix s)) candidates))

(defun x-company-select-candidate (pred)
  "Select either the next or previous candidate in the candidate list based on
the comparison of the ‘company-pseudo-tooltip-overlay’ height and 0 using PRED."
  (let ((ov company-pseudo-tooltip-overlay))
    (if (and ov (apply pred (list (overlay-get ov 'company-height) 0)))
        (company-select-previous)
      (company-select-next))))

(defun x-company-next-candidate ()
  "Select the next available candidate, taking into account if the candidate
list is flipped or not."
  (interactive)
  (x-company-select-candidate #'<))

(defun x-company-previous-candidate ()
  "Select the previous available candidate, taking into account if the candidate
list is flipped or not."
  (interactive)
  (x-company-select-candidate #'>))

(use-package company
  :bind (:map company-active-map
         ("C-j" . #'x-company-next-candidate)
         ("C-k" . #'x-company-previous-candidate))
  :hook ((conf-mode prog-mode) . company-mode)
  :custom
  (company-minimum-prefix-length 1)
  (company-idle-delay (lambda () (unless (company-in-string-or-comment) 0)))
  (company-selection-wrap-around t)
  (company-tooltip-align-annotations t)
  (company-tooltip-flip-when-above t)
  (company-frontends '(company-pseudo-tooltip-unless-just-one-frontend
                       company-preview-frontend
                       company-echo-metadata-frontend))
  (company-transformers '(x-company-require-prefix
                          company-sort-by-backend-importance)))

;;; Increment- and Decrement Numbers
(defun x-increment-number-at-point (&optional arg)
  "Increment the number at point by ARG or 1 if ARG is nil.  If called
interactively, the universal argument can be used to specify ARG.  If
the number at point has leading zeros then the width of the number is
preserved."
  (interactive "*p")
  (save-excursion
    (save-match-data
      (skip-chars-backward "0123456789")
      (when (eq (char-before (point)) ?-)
    (goto-char (1- (point))))
      (when (re-search-forward "-?\\([0-9]+\\)" nil 'noerror)
    (let ((answer (+ (string-to-number (match-string 0) 10)
             (or arg 1)))
          (width (length (match-string 1))))
      (replace-match
       (format
        (concat "%0" (int-to-string (if (< answer 0) (1+ width) width)) "d")
        answer)))))))

(defun x-decrement-number-at-point (&optional arg)
  "The same as ‘x-increment-number-at-point’, but ARG is negated."
  (interactive "*p")
  (x-increment-number-at-point (- (or arg 1))))

(keymap-global-set "C-c a" #'x-increment-number-at-point)
(keymap-global-set "C-c x" #'x-decrement-number-at-point)

;;; Indentation Settings
(setq-default
 tab-width 4
 indent-tabs-mode t)
(customize-set-variable 'evil-shift-width
                        (default-value 'tab-width))

(defvar x-indentation-settings
  '((c-mode :extra-vars (c-basic-offset))
    (css-mode :extra-vars (css-indent-offset))
    (emacs-lisp-mode :spaces t)
    (graphviz-dot-mode :extra-vars (graphviz-dot-indent-width))
    (lisp-mode :spaces t)
    (org-mode :spaces t)
    (python-mode :extra-vars (python-indent-offset))
    (sgml-mode :width 2 :extra-vars (sgml-basic-offset))
    (sh-mode :extra-vars (sh-basic-offset)))
  "A list of per-mode indentation settings.  Each list contains a
major-mode and the 3 optional keyword arguments of :spaces, :width, and
:extra-vars.  When setting the settings for a given major-mode, the
settings will also be applied for that mode’s tree-sitter variant.

If :spaces is non-nil, then indentation will be performed with spaces
instead of tabs characters.

If :width is non-nil, then it will override the modes given tab-width.

If :extra-vars is non-nill, then it shall be a list of additional
mode-specific variables that need to be assigned the desired
indentation-width.")

(defun x-set-indentation-settings ()
  "Apply the indentation settings specified by ‘x-indentation-settings’."
  (interactive)
  (dolist (plist x-indentation-settings)
    (let* ((mode (car plist))
           (args (cdr plist))
           (width (or (plist-get args :width)
                      (default-value 'tab-width)))
           (spaces (or (plist-get args :spaces)
                       (not (default-value 'indent-tabs-mode))))
           (extra (plist-get args :extra-vars))
           (callback
            (λ (indent-tabs-mode (when spaces -1))
               (setq-local tab-width width
                           evil-shift-width width)
               (dolist (var extra)
                 (set var width))))
           (mode-hook (intern (concat (symbol-name mode) "-hook")))
           (mode-ts (intern (concat
                             (string-remove-suffix 
                              "-mode" (symbol-name mode))
                             "-ts-mode"))))
      (dolist (hook (list (x-mode-to-hook mode)
                          (x-mode-to-hook (x-mode-to-ts-mode mode))))
        (add-hook hook callback 95)))))

(x-set-indentation-settings)

;;; Git Integration
(use-package magit
  :bind ("C-c g" . magit-status)
  :custom
  (magit-display-buffer-function
   #'magit-display-buffer-same-window-except-diff-v1))

(use-package magit-todos
  :after magit
  :init (magit-todos-mode))

(defun x-magit-status ()
  (interactive)
  (thread-last
    (project-current t)
    (project-root)
    (magit-status)))

(require 'project)
(add-to-list 'project-switch-commands '(x-magit-status "Git status" ?g))

;;; Tree-Sitter
(when (treesit-available-p)
  (setq treesit-language-source-alist
        '((cpp   "https://github.com/tree-sitter/tree-sitter-cpp")
          (elisp "https://github.com/Wilfred/tree-sitter-elisp")
          (gomod "https://github.com/camdencheek/tree-sitter-go-mod")
          (html  "https://github.com/tree-sitter/tree-sitter-html")))

  (defun x-treesit-source-sync ()
    "Install all the tree-sitter grammars in
‘treesit-language-source-alist’.  This function does not assert whether
or not the grammar is already installed, making it useful for updating
existing grammars."
    (interactive)
    (dolist (spec treesit-language-source-alist)
      (treesit-install-language-grammar (car spec))))

  (thread-last
    (mapcar #'car treesit-language-source-alist)
    (seq-remove #'treesit-language-available-p)
    (mapc #'treesit-install-language-grammar)))

;;; Language Server Protocol
(use-package eglot
  :hook ((c-mode      . eglot-ensure)
         (c++-mode    . eglot-ensure)
         (c-ts-mode   . eglot-ensure)
         (c++-ts-mode . eglot-ensure))
  :bind
  (:map eglot-mode-map
        ("C-c l a" . #'eglot-code-actions)
        ("C-c l r" . #'eglot-rename))
  :init
  (fset #'jsonrpc--log-event #'ignore)
  :custom
  (eglot-events-buffer 0)
  (eglot-extend-to-xref t)
  :config
  (setq eglot-managed-mode-hook
        (list (λ (eglot-inlay-hints-mode -1))))
  (dolist (feature '(eldoc flymake))
    (add-to-list 'eglot-stay-out-of feature))
  (with-eval-after-load 'eglot
    (add-to-list 'eglot-server-programs
                 '((c-mode c-ts-mode c++-mode c++-ts-mode)
                   . ("clangd" "--header-insertion=never")))))

(use-package eglot-booster
	:after eglot
	:config	(eglot-booster-mode))

;;; Automatically Create Directories
(defun x-auto-create-directories (original-function filename &rest arguments)
  "Automatically create and delete parent directories of files.  This
is an ‘:override’ advice for ‘find-file’ and friends.  It
automatically creates the parent directory (or directories) of the
file being visited, if necessary.  It also sets a buffer-local
variable so that the user will be prompted to delete the newly created
directories if they kill the buffer without saving it."
  (let (dirs-to-delete)
    (let* ((dir-to-create (file-name-directory filename))
           (current-dir dir-to-create))
      ;; We want to go up each directory component and add them to
      ;; ‘dirs-to-delete’ individually.
      (while (not (file-exists-p current-dir))
        (push current-dir dirs-to-delete)
        (setq current-dir (file-name-directory
                           (directory-file-name current-dir))))

      (unless (file-exists-p dir-to-create)
        (make-directory dir-to-create 'parents)))

    ;; Use ‘prog1’ so that we maintain the original return value
    (prog1 (apply original-function filename arguments)
      (when dirs-to-delete
        (setq-local x-dirs-to-delete (reverse dirs-to-delete))

        ;; When we kill the buffer we want to ask if we should delete parent
        ;; directories *unless* the buffer was saved, in which case we don’t
        ;; want to do anything.
        (add-hook 'kill-buffer-hook #'x-delete-directories-if-appropriate
                  'depth 'local)
        (add-hook 'after-save-hook #'x-remove-auto-directory-hooks
                  'depth 'local)))))

(dolist (command #'(find-file
                    find-alternate-file
                    write-file))
  (advice-add command :around #'x-auto-create-directories))

(defun x-delete-directories-if-appropriate ()
  "Delete parent directories if appropriate.  This is a function for
‘kill-buffer-hook’.  If ‘x-auto-create-directories’ created the
directory containing the file for the current buffer automatically,
then offer to delete it.  Otherwise, do nothing.  Also clean up
related hooks."
  (unless (file-exists-p buffer-file-name)
    (dolist (dir-to-delete x-dirs-to-delete)
      (when (and (stringp dir-to-delete)
                 (file-exists-p dir-to-delete)
                 (y-or-n-p (format "Also delete directory ‘%s’?"
                                   (directory-file-name dir-to-delete))))
        (delete-directory dir-to-delete)))))

(defun x-remove-auto-directory-hooks ()
  "Clean up directory-deletion hooks, if necessary."
  (remove-hook 'kill-buffer-hook #'x-delete-directories-if-appropriate 'local)
  (remove-hook 'after-save-hook #'x-remove-auto-directory-hooks 'local))

;;; Colorize Compilation Buffer
(require 'ansi-color)
(defun x-colorize-buffer ()
  "Parse ANSI escape sequences in the current buffer."
  (let ((inhibit-read-only t))
    (ansi-color-apply-on-region (point-min) (point-max))))
(add-hook 'compilation-filter-hook #'x-colorize-buffer)

;;; User Interface Themeing
(load-theme 'mango 'no-confirm)
(set-fringe-style (cons 32 32))

(defvar x-alpha-background 90
  "The opacity of a graphical Emacs frame, ranging from 0–100.  A value
of 0 is fully transparent while a value of 100 is fully opaque.")

(defun x-set-alpha-background (value)
  "Set the current frames’ background opacity to VALUE."
  (interactive "NOpacity [0–100]: ")
  (set-frame-parameter nil 'alpha-background value))
(add-to-list
 'default-frame-alist (cons 'alpha-background x-alpha-background))

(defvar x-monospace-font '("Iosevka Smooth" :weight regular :height 160)
  "The default monospace font to use.  This is a list containing a
font name, font weight, and font height in that order.")

(defvar x-proportional-font '("Ysabeau" :weight light :height 180)
  "The default proportional font to use.  This is a list containing a
font name, font weight, and font height in that order.")

(let* ((mono-family (car x-monospace-font))
       (mono-props  (cdr x-monospace-font))
       (prop-family (car x-proportional-font))
       (prop-props  (cdr x-proportional-font))
       (mono-weight (plist-get mono-props :weight))
       (mono-height (plist-get mono-props :height))
       (prop-weight (plist-get prop-props :weight))
       (prop-height (plist-get prop-props :height)))
  (set-face-attribute 'default nil
                      :font mono-family
                      :weight mono-weight
                      :height mono-height)
  (set-face-attribute 'fixed-pitch nil
                      :font mono-family
                      :weight mono-weight
                      :height mono-height)
  (set-face-attribute 'variable-pitch nil
                      :font prop-family
                      :weight prop-weight
                      :height prop-height))

;;; C-Style
(defun x-c-defun-open-safe (_syntax _position)
  (if (c-cpp-define-name)
      '(after)
    '(before after)))

(defun x-c (_syn _pos)
  (message "OMG")
  '(before))

(c-add-style
 "mango"
 '((indent-tabs-mode            . t)
   (c-backslash-column          . 80)
   (c-backslash-max-column      . 80)
   (c-basic-offset              . 4)
   (c-block-comment-prefix      . "")
   (c-comment-only-line-offset  . 0)
   (c-label-minimum-indentation . 0)
   (c-cleanup-list . (brace-else-brace
                      brace-elseif-brace
                      brace-catch-brace
                      comment-close-slash
                      scope-operator))
   (c-offsets-alist . ((label                 . [0])
                       (arglist-intro         . +)
                       (arglist-cont          . 0)
                       (arglist-cont-nonempty . +)
                       (arglist-close         . 0)))
   (c-hanging-braces-alist . ((defun-open . x-c-defun-open-safe)
                              (defun-close before)
                              (class-open after)
                              (class-close before)
                              (block-open after)
                              (block-close . c-snug-do-while)
                              (brace-list-open after)
                              (brace-list-close before)
                              (extern-lang-open after)
                              (extern-lang-close before)
                              (substatement-open after)
                              (statement-case-open after)))
   (c-hanging-colons-alist . ((case-label after)
                              (label after)))))
(customize-set-variable 'c-default-style "mango")

;;; Emacs Calculator
(setq calc-display-trail nil)

;;; Emacs Tetris
(defun x-tetris-rotate-mirror ()
  (interactive)
  (tetris-rotate-next)
  (tetris-rotate-next))

(use-package tetris
  :hook (tetris-mode . (lambda () (evil-local-mode -1)))
  :bind
  (:map tetris-mode-map
    ("a"   . #'tetris-move-left)
    ("d"   . #'tetris-move-right)
    ("k"   . #'tetris-rotate-next)
    (";"   . #'tetris-rotate-prev)
    ("l"   . #'tetris-move-down)
    ("o"   . #'x-tetris-rotate-mirror)
    ("SPC" . #'tetris-move-bottom)))
(put 'narrow-to-page 'disabled nil)