path: root/emacs/.config/emacs-kj/init.el

;;; -*- lexical-binding: t; -*-
(setq package-enable-at-startup nil)
(setq straight-check-for-modifications nil)
(defvar bootstrap-version)
(let ((bootstrap-file
       (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
      (bootstrap-version 6))
  (unless (file-exists-p bootstrap-file)
    (with-current-buffer
        (url-retrieve-synchronously
         "https://raw.githubusercontent.com/radian-software/straight.el/develop/install.el"
         'silent 'inhibit-cookies)
      (goto-char (point-max))
      (eval-print-last-sexp)))
  (load bootstrap-file nil 'nomessage))

(setq user-full-name "KJ Orbekk"
      user-mail-address "kj@orbekk.com")

(setq startup-time (current-time))
(setq initial-scratch-message
      (format ";; Emacs startup %s."
              (format-time-string "%F %T %z" startup-time)))
(setq inhibit-startup-message t)

(server-start)

(setq custom-file (expand-file-name "emacs-custom.el" user-emacs-directory))
(load custom-file :noerror t)

(defalias 'yes-or-no-p 'y-or-n-p)

(straight-use-package 'use-package)
(use-package straight
  :custom (straight-use-package-by-default t))

;; (let ((my-font "Iosevka-18"))
;;   (set-face-attribute 'default t :font my-font)
;;   (set-frame-font my-font))
(set-language-environment "utf-8")
;; (set-default-coding-systems 'utf-8)
(setq-default indent-tabs-mode nil)
(setq sentence-end-double-space nil)
(setq save-interprogram-paste-before-kill t)
(setq enable-recursive-minibuffers t)
;; This interferes with meow highlighting with some themes.
; (global-hl-line-mode 1)
(global-auto-revert-mode 1)

(setq visible-bell t
      ring-bell-function 'ignore)

;; Backup file settings.
;; Keep backups, but avoid same directory since it can be slow on tramp.
(setq backup-directory-alist `(("." . "~/.cache/emacs-backups"))
      version-control t
      delete-old-versions -1
      vc-make-backup-files t
      create-lockfiles nil)

(use-package doom-themes)

;; ;; Modus theme setup.
(use-package emacs
  :init
  ;; Add all your customizations prior to loading the themes
  (setq modus-themes-region '(accented))
  :config
  ;; Load the theme of your choice:
  (load-theme 'modus-operandi) ;; OR (load-theme 'modus-vivendi)
  :bind ("<f5>" . modus-themes-toggle))

(setq alert-default-style 'libnotify)

(when window-system
  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (tooltip-mode -1)
  (menu-bar-mode -1)
  (use-package all-the-icons
    :if (display-graphic-p)))
(setq inhibit-compacting-font-caches t)
(setq use-dialog-box nil)

(use-package doom-modeline
  :ensure t
  :init (doom-modeline-mode 1))

(use-package emojify
  :bind
  (("C-c C-i C-e" . emojify-insert-emoji))
  :hook (after-init . global-emojify-mode)
  :config
  (emojify-set-emoji-styles '(unicode)))

(setq-default show-trailing-whitespace t)
(dolist (mode '(calendar-mode-hook eshell-mode-hook term-mode-hook))
  (add-hook mode
            (lambda (&rest args)
              (setq show-trailing-whitespace nil))))

(use-package rainbow-delimiters
  :defer t
  :hook (prog-mode-hook . #'rainbow-delimiters-mode))

(column-number-mode)
(set-fringe-mode 10)
(setq next-screen-context-lines 10)

(use-package avy
  :bind
  (("C-c l" . avy-goto-char)
   ("C-c n" . avy-goto-line))
  :config
  (setq avy-keys '(?a ?o ?e ?u ?i ?d ?h ?t ?n ?s))
  (defun avy-action-embark (pt)
  (unwind-protect
      (save-excursion
        (goto-char pt)
        (embark-act))
    (select-window
     (cdr (ring-ref avy-ring 0))))
  t)

(setf (alist-get ?. avy-dispatch-alist) 'avy-action-embark)
  )
(define-key isearch-mode-map (kbd "M-j") 'avy-isearch)

(winner-mode +1)

(use-package ace-window
  :bind
  (("C-c e" . ace-window))
  :config
  (setq aw-dispatch-always t)
  (setq aw-keys '(?a ?o ?e ?u ?i ?d ?h ?t ?n ?s))
  ;; Make ace window more visible
  ;; (custom-set-faces!
  ;;  '(aw-leading-char-face
  ;;    :foreground "white" :background "red"
  ;;    :weight bold :height 2.5 :box (:line-width 10 :color "red")))
  )

(defun kj/balance-main-window ()
  (balance-windows (window-main-window)))

(defun kj/split-window-below ()
  (interactive)
  (split-window-below)
  (kj/balance-main-window)
  (other-window 1))

(defun kj/split-window-right ()
  (interactive)
  (split-window-right)
  (kj/balance-main-window)
  (other-window 1))

(global-set-key (kbd "C-x 3") #'kj/split-window-right)
(global-set-key (kbd "C-x 2") #'kj/split-window-below)

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

(use-package savehist
  :init
  (savehist-mode))

;; Rebind C-x?
;; (define-key key-translation-map "\C-t" "\C-x")
;; (define-key key-translation-map "\C-x" "\C-t")

(use-package marginalia
  :bind
  (:map minibuffer-local-map
	("M-n" . marginalia-cycle))
  :init
  (marginalia-mode))

(use-package embark
  :ensure t

  :bind
  (("C-." . embark-act)
   ("C-;" . embark-dwim)
   ("C-h C-b" . embark-bindings))

  :init
  (setq prefix-help-command #'embark-prefix-help-command)

  :config

  ;; Hide the mode line of the Embark live/completions buffers
  (add-to-list 'display-buffer-alist
               '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
		 .
                 (window-parameters (mode-line-format . none)))))

(use-package embark-consult
  :ensure t
  :after (embark consult)
  :demand t
  :hook (embark-mode-hook . consult-preview-at-point-mode))

;; For editing grep buffers.
(use-package wgrep)
(use-package deadgrep
  :bind ("M-s g" . deadgrep))

;; For recent files.
(setq recentf-max-saved-items 1000)
(setq recentf-keep (list (defun kj/recentf-keep (file)
                            t)))
(recentf-mode 1)
(run-at-time nil (* 5 60) 'recentf-save-list)

(setq global-mark-ring-max 500
      mark-ring-max 16)

;; Example configuration for Consult
(use-package consult
  ;; Replace bindings. Lazily loaded due by `use-package'.
  :bind (;; C-c bindings (mode-specific-map)
         ("C-c h" . consult-history)
         ("C-c m" . consult-mode-command)
         ("C-c k" . consult-kmacro)
         ;; C-x bindings (ctl-x-map)
         ("C-x M-:" . consult-complex-command)     ;; orig. repeat-complex-command
         ("C-x b" . consult-buffer)                ;; orig. switch-to-buffer
         ("C-x C-b" . consult-buffer)                ;; orig. switch-to-buffer
         ("C-x 4 b" . consult-buffer-other-window) ;; orig. switch-to-buffer-other-window
         ("C-x 5 b" . consult-buffer-other-frame)  ;; orig. switch-to-buffer-other-frame
         ("C-x r b" . consult-bookmark)            ;; orig. bookmark-jump
         ("C-x p b" . consult-project-buffer)      ;; orig. project-switch-to-buffer
	 ("C-c f r" . consult-recent-file)
         ;; Custom M-# bindings for fast register access
         ("M-#" . consult-register-load)
         ("M-'" . consult-register-store)          ;; orig. abbrev-prefix-mark (unrelated)
         ("C-M-#" . consult-register)
         ;; Other custom bindings
         ("M-y" . consult-yank-pop)                ;; orig. yank-pop
         ("<help> a" . consult-apropos)            ;; orig. apropos-command
         ;; M-g bindings (goto-map)
         ("M-g e" . consult-compile-error)
         ("M-g f" . consult-flymake)               ;; Alternative: consult-flycheck
         ("M-g g" . consult-goto-line)             ;; orig. goto-line
         ("M-g M-g" . consult-goto-line)           ;; orig. goto-line
         ("M-g o" . consult-outline)               ;; Alternative: consult-org-heading
         ("M-g m" . consult-mark)
         ("M-g k" . consult-global-mark)
         ("M-g i" . consult-imenu)
         ("M-g I" . consult-imenu-multi)
         ;; M-s bindings (search-map)
         ("M-s d" . consult-find)
         ("M-s D" . consult-locate)
         ;; ("M-s g" . consult-grep)
         ("M-s G" . consult-git-grep)
         ("M-s r" . consult-ripgrep)
         ("M-s l" . consult-line)
         ("M-s L" . consult-line-multi)
         ("M-s m" . consult-multi-occur)
         ("M-s k" . consult-keep-lines)
         ("M-s u" . consult-focus-lines)
         ;; Isearch integration
         ("M-s e" . consult-isearch-history)
         :map isearch-mode-map
         ("M-e" . consult-isearch-history)         ;; orig. isearch-edit-string
         ("M-s e" . consult-isearch-history)       ;; orig. isearch-edit-string
         ("M-s l" . consult-line)                  ;; needed by consult-line to detect isearch
         ("M-s L" . consult-line-multi)            ;; needed by consult-line to detect isearch
         ;; Minibuffer history
         :map minibuffer-local-map
         ("M-s" . consult-history)                 ;; orig. next-matching-history-element
         ("M-r" . consult-history))                ;; orig. previous-matching-history-element

  ;; Enable automatic preview at point in the *Completions* buffer. This is
  ;; relevant when you use the default completion UI.
  ;; :hook (completion-list-mode . consult-preview-at-point-mode)

  ;; The :init configuration is always executed (Not lazy)
  :init

  ;; Optionally configure the register formatting. This improves the register
  ;; preview for `consult-register', `consult-register-load',
  ;; `consult-register-store' and the Emacs built-ins.
  (setq register-preview-delay 0.5
        register-preview-function #'consult-register-format)

  ;; Optionally tweak the register preview window.
  ;; This adds thin lines, sorting and hides the mode line of the window.
  (advice-add #'register-preview :override #'consult-register-window)

  ;; Use Consult to select xref locations with preview
  (setq xref-show-xrefs-function #'consult-xref
        xref-show-definitions-function #'consult-xref)

  ;; Configure other variables and modes in the :config section,
  ;; after lazily loading the package.
  :config

  ;; Use consult for completion.
  (setq completion-in-region-function #'consult-completion-in-region)

  ;; Optionally configure preview. The default value
  ;; is 'any, such that any key triggers the preview.
  (setq consult-preview-key '(:debounce 0.3 any))
  ;; (setq consult-preview-key (kbd "M-."))
  ;; (setq consult-preview-key (list (kbd "<S-down>") (kbd "<S-up>")))
  ;; For some commands and buffer sources it is useful to configure the
  ;; :preview-key on a per-command basis using the `consult-customize' macro.
  ;; (consult-customize
  ;;  consult-theme
  ;;  :preview-key '(:debounce 0.2 any)
  ;;  consult-ripgrep consult-git-grep consult-grep
  ;;  consult-bookmark consult-recent-file consult-xref
  ;;  consult--source-bookmark consult--source-recent-file
  ;;  consult--source-project-recent-file
  ;;  :preview-key (kbd "M-."))

  ;; Optionally configure the narrowing key.
  ;; Both < and C-+ work reasonably well.
  (setq consult-narrow-key "<") ;; (kbd "C-+")

  ;; Optionally make narrowing help available in the minibuffer.
  ;; You may want to use `embark-prefix-help-command' or which-key instead.
  ;; (define-key consult-narrow-map (vconcat consult-narrow-key "?") #'consult-narrow-help)

  ;; By default `consult-project-function' uses `project-root' from project.el.
  ;; Optionally configure a different project root function.
  ;; There are multiple reasonable alternatives to chose from.
  ;;;; 1. project.el (the default)
  ;;(setq consult-project-function #'consult--default-project-function)
  ;;;; 2. projectile.el (projectile-project-root)
  (autoload 'projectile-project-root "projectile")
  (setq consult-project-function (lambda (_) (projectile-project-root)))
  ;;;; 3. vc.el (vc-root-dir)
  ;; (setq consult-project-function (lambda (_) (vc-root-dir)))
  ;;;; 4. locate-dominating-file
  ;; (setq consult-project-function (lambda (_) (locate-dominating-file "." ".git")))
  )

(use-package orderless
  :init
  (setq completion-styles '(orderless basic)
        completion-category-defaults nil
        completion-category-overrides '((file (styles partial-completion)))))

(use-package which-key
  :init
  (which-key-mode))

(straight-use-package
 '(magit :type git :host github :repo "magit/magit"))
(use-package magit)
(use-package org
  :config
  (org-babel-do-load-languages 'org-babel-load-languages
			       '((emacs-lisp . t)
				 (shell . t)))
  (setq org-confirm-babel-evaluate nil
        org-return-follows-link t
        )
  (require 'org-tempo))

(use-package mixed-pitch
  :hook
  (text-mode . mixed-pitch-mode)
  (org-mode . mixed-pitch-mode)
  )

(set-face-attribute 'default nil :font "Iosevka" :height 150)
(unless (equal system-name "minideck")
  (set-face-attribute 'fixed-pitch nil :font "Iosevka" :height 150)
  (set-face-attribute 'variable-pitch nil :font "Iosevka Etoile"))

(setq compilation-ask-about-save nil)
(use-package ob-async)

(use-package direnv
  :config
  (setq direnv-always-show-summary nil)
  (direnv-mode))

(use-package projectile
  :ensure t
  :init
  (projectile-mode +1)
  :bind (:map projectile-mode-map
              ("C-x p" . projectile-command-map)))

(use-package ediff
  :init
  (setq ediff-diff-options "-w" ; turn off whitespace checking
	ediff-split-window-function #'split-window-horizontally
	ediff-window-setup-function #'ediff-setup-windows-plain))

(use-package anzu
  :config
  (global-anzu-mode +1)
  (global-set-key [remap query-replace] 'anzu-query-replace)
  (global-set-key [remap query-replace-regexp] 'anzu-query-replace-regexp))

(defun meow-setup ()
  (setq meow-replace-state-name-list
        '((normal . "N")
          (motion . "M")
          (keypad . "🖩")
          (insert . "I")
          (beacon . "📻")))
  (setq meow-cheatsheet-layout meow-cheatsheet-layout-dvorak)
  (meow-leader-define-key
   '("1" . meow-digit-argument)
   '("2" . meow-digit-argument)
   '("3" . meow-digit-argument)
   '("4" . meow-digit-argument)
   '("5" . meow-digit-argument)
   '("6" . meow-digit-argument)
   '("7" . meow-digit-argument)
   '("8" . meow-digit-argument)
   '("9" . meow-digit-argument)
   '("0" . meow-digit-argument)
   '("/" . meow-keypad-describe-key)
   '("?" . meow-cheatsheet)
   '("b" . consult-buffer)
   ;;'("p" . projectile-command-map)
   )
  (meow-motion-overwrite-define-key
   ;; custom keybinding for motion state
   '("<escape>" . ignore))
  (meow-normal-define-key
   '("0" . meow-expand-0)
   '("9" . meow-expand-9)
   '("8" . meow-expand-8)
   '("7" . meow-expand-7)
   '("6" . meow-expand-6)
   '("5" . meow-expand-5)
   '("4" . meow-expand-4)
   '("3" . meow-expand-3)
   '("2" . meow-expand-2)
   '("1" . meow-expand-1)
   '("-" . negative-argument)
   '(";" . meow-reverse)
   '("," . meow-inner-of-thing)
   '("." . meow-bounds-of-thing)
   '("@" . er/expand-region)
   '("<" . meow-beginning-of-thing)
   '(">" . meow-end-of-thing)
   '("a" . meow-append)
   '("A" . meow-open-below)
   '("b" . meow-back-word)
   '("B" . meow-back-symbol)
   '("c" . meow-change)
   '("d" . meow-delete)
   '("D" . meow-backward-delete)
   '("e" . meow-line)
   '("E" . meow-goto-line)
   '("f" . meow-find)
   '("g" . meow-cancel-selection)
   '("G" . meow-grab)
   '("h" . meow-left)
   '("H" . meow-left-expand)
   '("i" . meow-insert)
   '("I" . meow-open-above)
   '("j" . meow-join)
   '("k" . meow-kill)
   '("l" . meow-till)
   '("m" . meow-mark-word)
   '("M" . meow-mark-symbol)
   '("n" . meow-next)
   '("N" . meow-next-expand)
   '("o" . meow-block)
   '("O" . meow-to-block)
   '("p" . meow-prev)
   '("P" . meow-prev-expand)
   '("q" . meow-quit)
   '("Q" . meow-goto-line)
   '("r" . meow-replace)
   '("R" . meow-swap-grab)
   '("s" . meow-search)
   '("/" . isearch-forward)
   '("?" . isearch-backward)
   '("t" . meow-right)
   '("T" . meow-right-expand)
   '("u" . meow-undo)
   '("U" . meow-undo-in-selection)
   '("v" . meow-visit)
   '("w" . meow-next-word)
   '("W" . meow-next-symbol)
   '("x" . meow-save)
   '("X" . meow-sync-grab)
   '("y" . meow-yank)
   '("z" . meow-pop-selection)
   '("P" . (lambda () (interactive) (forward-line -10)))
   '("N" . (lambda () (interactive) (forward-line 10)))
   '("'" . repeat)
   '("<escape>" . ignore))

  (add-hook 'git-commit-mode-hook #'meow-insert))

;; (use-package meow
;;   :bind
;;   :config
;;   (meow-setup)
;;   (meow-global-mode 1)
;;   ;; (meow-setup-indicator) ; Not needed with doom-modeline.
;;   (setq meow-use-clipboard t)
;;   ;; (add-to-list 'meow-keypad-start-keys '(?t . ?x))
;;   ;; (add-to-list 'meow-keypad-start-keys '(?x . ?t))
;;   (define-key meow-insert-state-keymap "\C-[" #'meow-insert-exit)
;;   )

(use-package emacs
  :hook (dired-mode . dired-omit-mode)
  :init
  (setq dired-dwim-target t  ; suggest a target for moving/copying intelligently
        dired-hide-details-hide-symlink-targets nil
        ;; don't prompt to revert, just do it
        dired-auto-revert-buffer #'dired-buffer-stale-p
        ;; Always copy/delete recursively
        dired-recursive-copies  'always
        dired-recursive-deletes 'top
        ;; Ask whether destination dirs should get created when copying/removing files.
        dired-create-destination-dirs 'ask))

;; (use-package dirvish
;;   :init
;;   (setq dirvish-hide-details nil)
;;   (dirvish-override-dired-mode))

(use-package diredfl
  :hook (dired-mode . diredfl-mode))

;; Tramp settings
(setq tramp-use-ssh-controlmaster-options nil
      tramp-default-method "ssh")

;; Org
(add-to-list 'org-export-backends 'md)

(load-file (locate-user-emacs-file "development.el"))
(load-file (locate-user-emacs-file "eshell.el"))

(setq math-additional-units
      '((ZiB "1024 * EiB" "Zebibyte")
        (EiB "1024 * PiB" "Exbibyte")
        (PiB "1024 * TiB" "Pebibyte")
        (TiB "1024 * GiB" "Tebibyte")
        (GiB "1024 * MiB" "Gibibyte")
        (MiB "1024 * KiB" "Mebibyte")
        (KiB "1024 * B" "Kibibyte")
        (B nil "Byte")
        (Zib "1024 * ZiB" "Zebibit")
        (Eib "1024 * PiB" "Exbibit")
        (Pib "1024 * TiB" "Pebibit")
        (Tib "1024 * GiB" "Tebibit")
        (Gib "1024 * Mib" "Gibibit")
        (Mib "1024 * Kib" "Mebibit")
        (Kib "1024 * b" "Kibibit")
        (b "B / 8" "Bit")))

;; If you use `org' and don't want your org files in the default location below,
;; change `org-directory'. It must be set before org loads!
(setq org-directory "~/org/")
(setq org-todo-keywords
      '((sequence
         "TODO(t)" "ACTIVE(a!)" "WAIT(w@/!)" "|" "DONE(d!)" "CANCELED(c@)")))
(setq org-refile-use-outline-path nil)
(setq org-refile-targets '((nil . (:maxlevel . 2))))
(setq org-log-into-drawer t)
(setq org-agenda-log-mode-items '(closed clock state))
(setq org-agenda-start-day nil)
(setq org-agenda-block-separator nil)
(setq org-agenda-compact-blocks t)
(setq org-agenda-start-with-log-mode nil)
(setq org-habit-show-all-today t)
(setq org-agenda-time-grid '((daily today require-timed) (800 1600) "......" "----------------------"))
(setq org-roam-directory (concat org-directory "roam/"))
(setq-default org-agenda-files '())
(dolist (file '("tasks.org"
                "running-2022.org"))
  (add-to-list 'org-agenda-files (concat org-roam-directory file)))
(setq org-roam-db-location (concat org-roam-directory "/org-roam.db"))
(setq org-export-with-toc nil)
(setq deft-directory org-directory)
(setq deft-recursive t)
;; Org html export
(setq org-html-htmlize-output-type 'css)
;; Website publish settings.
(defvar kj/publish-tag "publish")
(defvar kj/publish-directory "/ssh:orbekk@dragon.orbekk.com:/storage/srv/kj.orbekk.com")
(add-to-list 'org-modules 'org-habit)

					; (setq org-appear-autolinks t)
					; (use-package! org-appear
					;   :hook (org-mode . org-appear-mode))

(setq org-log-done 'time)
(setq org-todo-keywords
      '((sequence
         "TODO(t)"  ; A task that needs doing & is ready to do
         "PROJ(p)"  ; A project, which usually contains other tasks
         "LOOP(r)"  ; A recurring task
         "STRT(s)"  ; A task that is in progress
         "WAIT(w)"  ; Something external is holding up this task
         "HOLD(h)"  ; This task is paused/on hold because of me
         "IDEA(i)"  ; An unconfirmed and unapproved task or notion
         "|"
         "DONE(d!)"  ; Task successfully completed
         "KILL(k)") ; Task was cancelled, aborted or is no longer applicable
        (sequence
         "[ ](T)"   ; A task that needs doing
         "[-](S)"   ; Task is in progress
         "[?](W)"   ; Task is being held up or paused
         "|"
         "[X](D)")  ; Task was completed
        (sequence
         "|"
         "OKAY(o)"
         "YES(y)"
         "NO(n)")))

(setq org-journal-file-type 'weekly)
(setq org-journal-dir org-roam-directory)
(setq org-journal-file-format "journal-%Y-%m-%d.org")
(setq org-journal-enable-agenda-integration t)
(defun kj/org-journal-init ()
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (org-id-get-create)
    (org-set-property "category" "journal")))

(defun kj/org-journal-file-header (time)
  (format-time-string "#+title: Week of %F (%W)\n"
                      (org-journal--convert-time-to-file-type-time time)))
(setq org-journal-file-header #'kj/org-journal-file-header)
(add-hook 'org-journal-after-header-create-hook 'kj/org-journal-init)

(use-package org-pomodoro
  :ensure t
  :commands (org-pomodoro)
  :config
  (setq
   org-pomodoro-manual-break t
   org-pomodoro-time-format "%m"
   org-pomodoro-format "🍅%s"
   org-pomodoro-play-sounds nil
   alert-user-configuration (quote ((((:category . "org-pomodoro")) libnotify nil)))))

;; Low menu delay.
(setq which-key-idle-delay .5)

;; Allow longer output in compilation buffer.
(add-to-list 'compilation-filter-hook #'comint-truncate-buffer)
(setq comint-buffer-maximum-size 10000)

;; Replace values in an alist from a list of replacements.
;;
;; Example:
;;   (kj/assq-replace '((:a . 1)) '((:a . 2)))
(defun kj/assq-replace (replacements alist)
  (let ((replace1 (lambda (aelem alist)
                    (cons aelem (assq-delete-all (car aelem) alist)))))
    (if replacements
        (kj/assq-replace (cdr replacements)
                         (funcall replace1 (car replacements) alist))
      alist)))


(use-package idle-highlight-mode
  :config
  (setq idle-highlight-idle-time 0.2)
  (set-face-attribute 'idle-highlight nil :inherit 'underline)
  :hook ((prog-mode text-mode) . idle-highlight-mode))

(use-package paredit
  :hook ((lisp-mode emacs-lisp-mode) . paredit-mode)
  :bind (:map paredit-mode-map
              ("M-k"   . paredit-raise-sexp)
              ("M-I"   . paredit-splice-sexp))
  :hook (paredit-mode
         . (lambda ()
             (unbind-key "M-r" paredit-mode-map)
             (unbind-key "M-s" paredit-mode-map))))

(use-package emacs
  :bind
  (("C-w" . backward-kill-word)
   ("C-c d" . kill-region)
   ("C-c C-b C-r" . revert-buffer)
   ("C-c C-r C-e" . consult-flymake)
   ("C-c C-r C-f" . eglot-format)
   ("C-c C-r C-g" . recompile)
   ("C-c C-r C-a" . eglot-code-actions)
   ("C-c C-r C-r" . eglot-rename)
   ("C-c C-i C-c" . insert-char)
   ("C-c C-b C-u" . winner-undo)
   ("C-c C-b U" . winner-redo)
   ("C-<tab>" . completion-at-point)))

(let ((google-config-file
       (expand-file-name "google.el" user-emacs-directory)))
  (when (file-exists-p google-config-file)
    (load-file google-config-file)))

(define-key isearch-mode-map [(control return)]
  #'isearch-exit-other-end)
(defun isearch-exit-other-end ()
  "Exit isearch, at the opposite end of the string."
  (interactive)
  (isearch-exit)
  (goto-char isearch-other-end))

(setq case-fold-search t)
(setq case-replace t)

(use-package expand-region
  :bind (("C-@" . #'er/expand-region)))

(use-package multiple-cursors)

(use-package ace-mc
  :bind (:map kj/leader-map
              ("h" . ace-mc-add-multiple-cursors)
              ("M-h" . ace-mc-add-single-cursor)))

;; Disable VC over tramp.
(setq-default vc-handled-backends nil)
(defun kj/vc-off-if-remote ()
  (if (file-remote-p (buffer-file-name))
      (setq-local vc-handled-backends nil)))
(add-hook 'find-file-hook 'kj/vc-off-if-remote)

(use-package selected
  :demand t
  :diminish selected-minor-mode
  :bind (:map selected-keymap
              ("[" . align-code)
              ("f" . fill-region)
              ("U" . unfill-region)
              ("d" . downcase-region)
              ("r" . reverse-region)
              ("S" . sort-lines))
  :config
  (selected-global-mode 1))

(setq kj/some-lines 6)
(defun kj/forward-some-lines ()
  (interactive)
  (forward-line kj/some-lines))
(defun kj/previous-some-lines ()
  (interactive)
  (previous-line kj/some-lines))

(use-package emacs
  :init
  (defvar kj/leader-map
    (make-sparse-keymap)
    "Keymap for leader key")
  :bind (:repeat-map kj/leader-map
                     ("." . mc/mark-next-like-this)
                     ("," . mc/mark-previous-like-this)
                     ("C-." . mc/skip-to-next-like-this)
                     ("C-," . mc/skip-to-previous-like-this)
                     ("<" . mc/unmark-next-like-this)
                     (">" . mc/unmark-previous-like-this)
                     ("*" . mc/mark-all-like-this)
                     ("w" . mc/mark-next-like-this-word)
                     ("W" . mc/mark-all-words-like-this)
                     ("s" . set-rectangular-region-anchor)
                     ("y" . mc/mark-next-like-this-symbol)
                     ("Y" . mc/mark-all-like-this-symbol)
                     ("d" . kj/forward-some-lines)
                     ("u" . kj/previous-some-lines)
                     ("C-SPC" . mc/mark-pop)
                     ("("     . mc/mark-all-symbols-like-this-in-defun)
                     ("C-("   . mc/mark-all-words-like-this-in-defun)
                     ("M-("   . mc/mark-all-like-this-in-defun)
                     :exit
                     ("$" . eshell)
                     ("b" . consult-buffer))

  :bind (("S-<down-mouse-1>")
         ("S-<mouse-1>" . mc/add-cursor-on-click))

  :bind (:map selected-keymap
              ("C-." . mc/skip-to-next-like-this)
              ("C-," . mc/skip-to-previous-like-this)
              ("." . mc/mark-next-like-this)
              ("," . mc/mark-previous-like-this)
              ("w" . mc/mark-next-like-this-word)
              ("W" . mc/mark-all-words-like-this)
              ("s" . set-rectangular-region-anchor)
              ("y" . mc/mark-next-like-this-symbol)
              ("Y" . mc/mark-all-like-this-symbol)))

(defvar kj/keys-minor-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "C-t") kj/leader-map)
    map)
  "Keymap for kj/keys-minor-mode")
(define-minor-mode kj/keys-minor-mode
  "A minor mode so that my key settings override annoying major modes."
  :init-value t
  :lighter " kj-keys")
(kj/keys-minor-mode 1)

;; Repeat commands (e.g., C-x o o o)
;; (use-package repeat-help
;;   :ensure t ;; or :straight t
;;   :hook (repeat-mode . repeat-help-mode)
;;   :config
;;   (setq repeat-help-popup-type "which-key"))
(repeat-mode 1)

;;; Window placement
;;; TODO: Test popper.el.
(global-set-key (kbd "C-`") #'window-toggle-side-windows)
(setq window-sides-slots '(0 0 2 2))  ; 2 right side windows
(setq switch-to-buffer-obey-display-actions t)
(setq switch-to-buffer-in-dedicated-window 'pop)
;; Prevent pop-up buffers from using new windows.
;; (add-to-list 'display-buffer-alist
;; 	     '("\\*Help" (display-buffer-same-window)))
;; (add-to-list 'display-buffer-alist
;; 	     '("\\*info" (display-buffer-same-window)))

(defun kj/popup-buffer (buffer condition)
  (or (s-matches-p (rx (| "*Help*"
                       "*info*"
                       (seq "*Messages*")
                       (seq "*eldoc " (* anything) "*")
                       (seq "*WoMan " (* anything) "*")
                       (seq "*man " (* anything) "*")
                       (seq "fig: " (* anything))
                       (seq "*htop*" (* anything))
                       (seq "*Proced*" (* anything))
                       (seq "*eshell*" (* anything))
                       "*Occur*")) buffer)
      (with-current-buffer buffer
        (apply #'derived-mode-p
               '(magit-mode
                 compilation-mode
                 comint-mode
                 Custom-mode ; For customization
                 fig-commit-mode)))))

(setq transient-display-buffer-action
      '(display-buffer-in-best-side
        (slot . 1)
        (inhibit-same-window . t)
        (window-parameters
         (no-other-window . t))))

(defun display-buffer-in-best-side (buffer alist)
  (display-buffer-in-side-window
   buffer
   (append (if (> (frame-width) 160)
               '((side . right)
                 (window-width . 80))
             '((side . bottom)
               (window-height . 0.5)))
           alist)))

(add-to-list 'display-buffer-alist
             `(kj/popup-buffer
                    (display-buffer-in-best-side)
                    (slot . 0)
                   ))

;; Calendar settings.
(setq calendar-week-start-day 1)
;; Show calendar week numbers.
(copy-face font-lock-constant-face 'calendar-iso-week-face)
(set-face-attribute 'calendar-iso-week-face nil
                    :height 0.7)
(setq calendar-intermonth-text
      '(propertize
        (format "%2d"
                (car
                 (calendar-iso-from-absolute
                  (calendar-absolute-from-gregorian (list month day year)))))
        'font-lock-face 'calendar-iso-week-face))

(setq ispell-local-dictionary "en_US")
(add-hook 'text-mode-hook (defun kj/flyspell-mode (&rest args)  (flyspell-mode 1)))
(add-hook 'prog-mode-hook (defun kj/flyspell-prog-mode (&rest args)  (flyspell-prog-mode 1)))