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

 (defvar my--file-name-handler-alist file-name-handler-alist)
 (setq gc-cons-threshold most-positive-fixnum
	gc-cons-percentage 0.6
	file-name-handler-alist nil)

 (if (fboundp 'tool-bar-mode)
   (tool-bar-mode -1))
 (if (fboundp 'set-scroll-bar-mode)
   (set-scroll-bar-mode nil))
 (if (fboundp 'menu-bar-mode)
   (menu-bar-mode -1))

 (setq package-enable-at-startup nil)

 (set-face-attribute 'default nil  :family "Hack" :height 110 :weight 'normal)

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

;; This file replaces itself with the actual configuration at first run.

;; We can't tangle without org!
(require 'org)
;; Open the configuration
(find-file (concat user-emacs-directory "init.org"))
;; tangle it
(org-babel-tangle)
;; load it
(load-file (concat user-emacs-directory "init.el"))
;; finally byte-compile it
(byte-compile-file (concat user-emacs-directory "init.el"))

 (defun tangle-init ()
   "If the current buffer is 'init.org' the code-blocks are
 tangled, and the tangled file is compiled."
   (interactive)
   (when (equal (buffer-file-name)
		 (expand-file-name (concat user-emacs-directory "init.org")))
     ;; Avoid running hooks when tangling.
     (let ((prog-mode-hook nil))
	(org-babel-tangle)
	(byte-compile-file (concat user-emacs-directory "init.el")))))

 ;; (add-hook 'after-save-hook 'tangle-init)

(setq emacs-load-start-time (current-time))

(setq custom-file (concat user-emacs-directory "custom.el"))
(if (file-exists-p (concat user-emacs-directory "custom.el"))
    (load-file (concat user-emacs-directory "custom.el")))

(require 'package)
;; ;;; Install into separate package dirs for each Emacs version, to prevent bytecode incompatibility
;; (let ((versioned-package-dir
;;        (expand-file-name (format "elpa-%s.%s" emacs-major-version emacs-minor-version)
;; 			 user-emacs-directory)))
;;   (setq package-user-dir versioned-package-dir))
(setq package-archives '(("melpa" . "~/elpa/melpa/")
			   ;; ("melpa-stable" . "~/elpa/melpa-stable/")
			   ("gnu" . "~/elpa/gnu/")
			   ("org" . "~/elpa/org/")
			   ("emacswiki" . "~/elpa/emacswiki/")))
;; (setq package-archives '(("gnu" . "https://mirrors.ustc.edu.cn/elpa/gnu/")
;; 			 ("melpa" . "https://mirrors.ustc.edu.cn/elpa/melpa/")
;; 			 ;; ("melpa-stable" . "https://mirrors.ustc.edu.cn/elpa/melpa-stable/")
;; 			 ("org" . "https://mirrors.ustc.edu.cn/elpa/org/")))
(package-initialize)

 (defvar bootstrap-version)
 (let ((bootstrap-file
	 (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
	(bootstrap-version 5))
   (unless (file-exists-p bootstrap-file)
     (with-current-buffer
	  (url-retrieve-synchronously
	   "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
	   'silent 'inhibit-cookies)
	(goto-char (point-max))
	(eval-print-last-sexp)))
   (load bootstrap-file nil 'nomessage))
   (setq straight-use-package-by-default t)

;; (straight-use-package 'use-package)
;; install use-package
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))
;; further reduce load time, from use-package official github page
(eval-when-compile
  (require 'use-package))
(setq use-package-always-ensure t)
(use-package diminish)
(require 'diminish)
(setq use-package-verbose t)

(use-package hydra
  :config
  (setq hydra-hint-display-type 'my/posframe)
  (defun my/hydra-posframe-show (str)
    (require 'posframe)
    (posframe-show
     " *hydra-posframe*"
     :string str
     :point (point)
     :internal-border-color "gray50"
     :internal-border-width 2
     :poshandler #'posframe-poshandler-frame-top-center))
  (defun my/hydra-posframe-hide ()
    (posframe-hide " *hydra-posframe*"))
  (setq hydra-hint-display-alist
	  (list (list 'my/posframe #'my/hydra-posframe-show #'my/hydra-posframe-hide))
	  hydra--work-around-dedicated nil))

 (use-package general
   :config
   (progn
     (general-create-definer my/normal-keys
	:states 'normal
	:keymaps 'override)
     (general-create-definer my/motion-keys
	:states 'motion
	:keymaps 'override)
     (general-create-definer my/non-insert-keys
	:states '(nromal visual motion)
	:keymaps 'override)
     (general-create-definer my/leader-keys
	:states '(normal visual motion emacs insert)
	:keymaps 'override
	:prefix "SPC"
	:non-normal-prefix "M-SPC")
     (general-create-definer my/leader-keys-major-mode
	:states '(normal visual motion emacs insert)
	:keymaps 'override
	:prefix ","
	:non-normal-prefix "M-,")
     (general-create-definer my/leader-keys-minor-mode
	:states '(normal visual motion emacs insert)
	:keymaps 'override
	:prefix ";"
	:non-normal-prefix "M-;")
     (general-create-definer my/all-states-keys
	:states '(normal visual motion emacs insert)
	:keymaps 'override)
     ;; (general-create-definer my/leader-keys-extra
     ;;   :states '(normal visual motion emacs insert)
     ;;   :keymaps 'override
     ;;   :prefix ";"
     ;;   :non-normal-prefix "M-;")
     ))

 ;;;###autoload
 (defun my/lisp-indent-function (indent-point state)
   "This function is the normal value of the variable `lisp-indent-function'.
 The function `calculate-lisp-indent' calls this to determine
 if the arguments of a Lisp function call should be indented specially.
 INDENT-POINT is the position at which the line being indented begins.
 Point is located at the point to indent under (for default indentation);
 STATE is the `parse-partial-sexp' state for that position.
 If the current line is in a call to a Lisp function that has a non-nil
 property `lisp-indent-function' (or the deprecated `lisp-indent-hook'),
 it specifies how to indent.  The property value can be:
 * `defun', meaning indent `defun'-style
   \(this is also the case if there is no property and the function
   has a name that begins with \"def\", and three or more arguments);
 * an integer N, meaning indent the first N arguments specially
   (like ordinary function arguments), and then indent any further
   arguments like a body;
 * a function to call that returns the indentation (or nil).
   `lisp-indent-function' calls this function with the same two arguments
   that it itself received.
 This function returns either the indentation to use, or nil if the
 Lisp function does not specify a special indentation."
   (let ((normal-indent (current-column))
	  (orig-point (point)))
     (goto-char (1+ (elt state 1)))
     (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t)
     (cond
      ;; car of form doesn't seem to be a symbol, or is a keyword
      ((and (elt state 2)
	     (or (not (looking-at "\\sw\\|\\s_"))
		 (looking-at ":")))
	(if (not (> (save-excursion (forward-line 1) (point))
		    calculate-lisp-indent-last-sexp))
	    (progn (goto-char calculate-lisp-indent-last-sexp)
		   (beginning-of-line)
		   (parse-partial-sexp (point)
				       calculate-lisp-indent-last-sexp 0 t)))
	;; Indent under the list or under the first sexp on the same
	;; line as calculate-lisp-indent-last-sexp.  Note that first
	;; thing on that line has to be complete sexp since we are
	;; inside the innermost containing sexp.
	(backward-prefix-chars)
	(current-column))
      ((and (save-excursion
	       (goto-char indent-point)
	       (skip-syntax-forward " ")
	       (not (looking-at ":")))
	     (save-excursion
	       (goto-char orig-point)
	       (looking-at ":")))
	(save-excursion
	  (goto-char (+ 2 (elt state 1)))
	  (current-column)))
      (t
	(let ((function (buffer-substring (point)
					  (progn (forward-sexp 1) (point))))
	      method)
	  (setq method (or (function-get (intern-soft function)
					 'lisp-indent-function)
			   (get (intern-soft function) 'lisp-indent-hook)))
	  (cond ((or (eq method 'defun)
		     (and (null method)
			  (> (length function) 3)
			  (string-match "\\`def" function)))
		 (lisp-indent-defform state indent-point))
		((integerp method)
		 (lisp-indent-specform method state
				       indent-point normal-indent))
		(method
		 (funcall method indent-point state))))))))

 (with-eval-after-load 'lisp-mode
   (setq lisp-indent-function 'my/lisp-indent-function))

(use-package try
  :commands try)

 (use-package evil
   :general
   (:keymaps 'override
	      :states 'insert
	      "C-j" 'evil-next-line
	      "C-k" 'evil-previous-line
	      "M-o" 'evil-open-below)
   :init
   (setq evil-want-keybinding nil)
   :config
   (define-key evil-insert-state-map [remap evil-complete-previous] 'hippie-expand)
   (my/normal-keys
     "gD" 'xref-find-definitions-other-window
     "gd" 'xref-find-definitions)
   (progn
     (evil-set-initial-state 'pdf-view-mode 'normal)
     (evil-set-initial-state 'pdf-outline-buffer-mode 'normal)
     (evil-set-initial-state 'paradox-menu-mode 'motion)
     (evil-set-initial-state 'calendar-mode 'normal)
     (evil-set-initial-state 'process-menu-mode 'motion)
     (evil-set-initial-state 'special-mode 'motion)
     (evil-set-initial-state 'pdf-occur-buffer-mode 'normal)
     (evil-set-initial-state 'imenu-list-major-mode 'normal)
     (evil-set-initial-state 'neotree-mode 'normal)
     (evil-set-initial-state 'youdao-dictionary-mode 'motion)
     (evil-set-initial-state 'flycheck-error-list-mode 'normal)
     (evil-set-initial-state 'nov-mode 'normal)
     (evil-set-initial-state 'lsp-ui-imenu-mode 'normal)
     (evil-set-initial-state 'helpful-mode 'normal)
     (evil-set-initial-state 'Custom-mode 'normal)
     (evil-set-initial-state 'occur-mode 'normal)
     (setq evil-insert-state-cursor '(bar "LimeGreen")
	    evil-normal-state-cursor '(box "darkorange")
	    evil-visual-state-cursor '(box "LightGoldenrod")
	    evil-emacs-state-cursor '(box "MediumPurple2")
	    evil-echo-state nil)
 ;;;###autoload
     (defun my/end-of-buffer ()
	"Go to beginning of last line in buffer.
 If last line is empty, go to beginning of penultimate one
 instead."
	(interactive)
	(goto-char (point-max))
	(beginning-of-line (and (looking-at-p "^$") 0)))
 ;;;###autoload
     (evil-define-motion my/evil-goto-line (count)
	"Go to the first non-blank character of line COUNT.
 By default the last line."
	:jump t
	:type line
	(if (null count)
	    (with-no-warnings (my/end-of-buffer))
	  (goto-char (point-min))
	  (forward-line (1- count)))
	(evil-first-non-blank))

     (global-set-key [remap evil-goto-line] #'my/evil-goto-line)
     (evil-mode 1)))

 (use-package evil-escape
   :diminish evil-escape-mode
   :init
   (with-eval-after-load 'company
	(add-hook 'evil-normal-state-entry-hook #'company-cancel))
   (setq evil-escape-key-sequence "jk"
	  evil-escape-unordered-key-sequence t)
   :config
   (evil-escape-mode))

(use-package evil-anzu
  :ghook ('after-init-hook #'global-anzu-mode)
  :general
  (my/leader-keys
    "rs" 'anzu-query-replace
    "rr" 'anzu-query-replace-regexp)
  :config
  (global-set-key [remap query-replace] 'anzu-query-replace)
  (global-set-key [remap query-replace-regexp] 'anzu-query-replace-regexp))

(use-package evil-exchange
  :general
  (my/normal-keys
    "gx" 'evil-exchange
    "gX" 'evil-exchange-cancel))

(use-package evil-nerd-commenter
  :general
  (my/leader-keys
    ";" 'evilnc-comment-operator
    "M-;" 'evilnc-copy-and-comment-operator
    "cl" 'evilnc-comment-or-uncomment-lines
    "cp" 'evilnc-comment-or-uncomment-paragraphs))

(use-package evil-matchit
  :general
  (:keymaps 'override
   :states '(normal visual)
   "%" 'evilmi-jump-items)
  (:keymaps 'evil-inner-text-objects-map
   "%" 'evilmi-jump-items)
  (:keymaps 'evil-outer-text-objects-map
   "%" 'evilmi-jump-items)
  :config
  (setq evilmi-always-simple-jump t)
  (global-evil-matchit-mode))

(use-package evil-surround
  :after evil
  :config
  (global-evil-surround-mode 1))

(use-package evil-snipe
  :diminish evil-snipe-local-mode
  :init
  (setq evil-snipe-show-prompt nil)
  :config
  (evil-snipe-mode 1)
  (evil-snipe-override-mode 1)
  (my/normal-keys
    "s" 'evil-snipe-s
    "S" 'evil-snipe-S))

(use-package evil-goggles
  :diminish evil-goggles-mode
  :after evil
  :config
  (evil-goggles-mode))

(use-package evil-indent-plus
  :general
  (:keymaps 'evil-inner-text-objects-map
   "i" 'evil-indent-plus-i-indent
   "I" 'evil-indent-plus-i-indent-up
   "J" 'evil-indent-plus-i-indent-up-down)
  (:keymaps 'evil-outer-text-objects-map
   "i" 'evil-indent-plus-a-indent
   "I" 'evil-indent-plus-a-indent-up
   "J" 'evil-indent-plus-a-indent-up-down))

(use-package evil-iedit-state
  :general
  (my/leader-keys "se" 'evil-iedit-state/iedit-mode)
  :config
  (setq iedit-current-symbol-default t
	  iedit-only-at-symbol-boundaries t
	  iedit-toggle-key-default nil))

(use-package evil-numbers
  :general
  (my/leader-keys
    "n" '(:ignore t :wk "numbers")
    "ni" 'evil-numbers/inc-at-pt
    "nd" 'evil-numbers/dec-at-pt
    "n." 'hydra-evil-numbers/body)
  :config
  (defhydra hydra-evil-numbers (:hint nil)
    "
Evil Numbers: [_i_] increase [_d_] decrease [0..9] prefix [_q_] exit
"
    ("i" evil-numbers/inc-at-pt)
    ("d" evil-numbers/dec-at-pt)
    ("q" nil :exit t)))

(use-package evil-args
  :after evil
  :general
  (my/normal-keys
    "gL" 'evil-forward-arg
    "gh" 'evil-backward-arg
    "gK" 'evil-jump-out-args)
  :config
  (define-key evil-inner-text-objects-map "a" 'evil-inner-arg)
  (define-key evil-outer-text-objects-map "a" 'evil-outer-arg))

(use-package evil-mc
  :commands (evil-mc-make-cursor-here
	       evil-mc-make-all-cursors
	       evil-mc-undo-all-cursors evil-mc-pause-cursors
	       evil-mc-resume-cursors evil-mc-make-and-goto-first-cursor
	       evil-mc-make-and-goto-last-cursor
	       evil-mc-make-cursor-move-next-line
	       evil-mc-make-cursor-move-prev-line evil-mc-make-cursor-at-pos
	       evil-mc-has-cursors-p evil-mc-make-and-goto-next-cursor
	       evil-mc-skip-and-goto-next-cursor evil-mc-make-and-goto-prev-cursor
	       evil-mc-skip-and-goto-prev-cursor evil-mc-make-and-goto-next-match
	       evil-mc-skip-and-goto-next-match evil-mc-skip-and-goto-next-match
	       evil-mc-make-and-goto-prev-match evil-mc-skip-and-goto-prev-match)
  :init
  (add-hook 'prog-mode-hook #'evil-mc-mode)
  (add-hook 'text-mode-hook #'evil-mc-mode)
  (my/normal-keys
    "gr" '(:ignore t :wk "evil-mc"))
  (setq evil-mc-incompatible-minor-modes
	  '(evil-escape-mode aggressive-indent-mode flycheck-mode flyspell-mode haskell-indent-mode haskell-indentation-mode yas-minor-mode)))

(use-package evil-lion
  :general
  (:states '(normal visual)
    "ga" 'evil-lion-left
    "gA" 'evil-lion-right)
  :config
  (setq evil-lion-left-align-key nil
	  evil-lion-right-align-key nil))

(use-package evil-owl
  :after evil
  :config
  (setq evil-owl-register-char-limit 100
	  evil-owl-display-method 'posframe
	  evil-owl-extra-posframe-args '(:internal-border-color "gray50"
					 :internal-border-width 2
					 :width 80))
  (evil-owl-mode))

(use-package evil-collection
  :config
  (with-eval-after-load 'reftex (evil-collection-reftex-setup))
  (with-eval-after-load 'magit (evil-collection-magit-todos-setup)))

 ;;;###autoload
 (defun my/kill-this-buffer (&optional arg)
   ;; copy from spacemacs
   "Kill the current buffer.
 If the universal prefix argument is used then kill also the window."
   (interactive "P")
   (if (window-minibuffer-p)
	(abort-recursive-edit)
     (if (equal '(4) arg)
	  (kill-buffer-and-window)
	(kill-buffer))))

 ;;;###autoload
 ;; from https://gist.github.com/3402786
 (defun my/toggle-maximize-buffer ()
   "Maximize buffer"
   (interactive)
   (if (and (= 1 (length (window-list)))
	     (assoc ?_ register-alist))
	(jump-to-register ?_)
     (progn
	(window-configuration-to-register ?_)
	(delete-other-windows))))

 ;;;###autoload
 (defun my/toggle-syntax-checking ()
   (interactive)
   (if (bound-and-true-p flycheck-mode)
	(progn
	  (flycheck-mode -1)
	  (message "Flycheck mode disabled in current buffer"))
     (progn
	(flycheck-mode 1)
	(message "Flycheck mode enabled in current buffer"))))

 ;;;###autoload
 (defun my/byte-compile-init-dir ()
   "Byte-compile all your dotfiles."
   (interactive)
   (byte-recompile-directory user-emacs-directory 0))

 ;; copy from spacemacs
 ;;;###autoload
 (defun my/alternate-buffer (&optional window)
   "Switch back and forth between current and last buffer in the
 current window."
   (interactive)
   (let ((current-buffer (window-buffer window)))
     ;; if no window is found in the windows history, `switch-to-buffer' will
     ;; default to calling `other-buffer'.
     (without-purpose (switch-to-buffer
			(cl-find-if (lambda (buffer)
				      (not (eq buffer current-buffer)))
				    (mapcar #'car (window-prev-buffers window)))))))

 ;;;###autoload
 (defun my/org-ref-open-pdf-at-point ( )
   "Open the pdf for bibtex key under point if it exists."
   (interactive)
   (require 'ivy-bibtex)
   (let* ((results (org-ref-get-bibtex-key-and-file))
	   (key (car results))
	   (pdf-file (car (bibtex-completion-find-pdf key))))
     (if (file-exists-p pdf-file)
	  (org-open-file pdf-file)
	(message "No PDF found for %s" key))))

 ;; restart emacs with --debut-init, copy from spacemacs
 ;;;###autoload
 (defun my/restart-emacs-debug-init (&optional args)
   "Restart emacs and enable debug-init."
   (interactive)
   (restart-emacs (cons "--debug-init" args)))

 ;;;###autoload
 (defun my/toggle-highlight-symbol ()
   (interactive)
   (if (bound-and-true-p highlight-symbol-mode)
	(progn
	  (highlight-symbol-mode -1)
	  (hl-line-mode 1)
	  (message "Highlight symbol mode disabled and hl-line-mode enabled in current buffer"))
     (progn
	(highlight-symbol-mode 1)
	(hl-line-mode -1)
	(message "Highlight symbol mode enabled and hl-line-mode disabled in current buffer"))))

 ;;;###autoload
 (defun my/toggle-flyspell ()
   (interactive)
   (if (bound-and-true-p flyspell-mode)
	(progn
	  (flyspell-mode -1)
	  (message "Flyspell mode disabled in current buffer"))
     (progn
	(flyspell-mode 1)
	(message "Flyspell mode enabled in current buffer"))))
 ;;;###autoload
 (defun my/toggle-color-identifiers ()
   (interactive)
   (if (bound-and-true-p color-identifiers-mode)
	(progn
	  (color-identifiers-mode -1)
	  (message "Color identifiers mode disabled in current buffer"))
     (progn
	(color-identifiers-mode 1)
	(message "Color identifiers mode enabled in current buffer"))))

 ;;;###autoload
 (defun my/show-current-time ()
   ;; show current time in minibuffer
   (interactive)
   (message (current-time-string)))

 ;;;###autoload
 (defun my/copy-file-name-to-clipboard ()
   "Copy the current buffer file name to the clipboard."
   (interactive)
   (let ((filename (if (equal major-mode 'dired-mode)
			default-directory
		      (buffer-file-name))))
     (when filename
	(kill-new filename)
	(message "Copied buffer file name '%s' to the clipboard." filename))))

 (prefer-coding-system 'utf-8)
 (set-default-coding-systems 'utf-8)
 ;; replace "yes" and "no" by "y" and "n"
 (defalias 'yes-or-no-p 'y-or-n-p)
 ;;display-time-mode
 (setq display-time-24hr-format t
	display-time-default-load-average nil
	display-time-day-and-date t)
 ;; (display-time-mode t)
 ;;
 (column-number-mode t)
 (size-indication-mode t)
 (blink-cursor-mode 0)
 (add-to-list 'default-frame-alist '(fullscreen . maximized))
 ;; auto save
 (auto-save-visited-mode t)
 (setq  auto-save-default t
	 auto-save-timeout 20
	 auto-save-interval 20)
 (defvar emacs-autosave-directory
   (concat user-emacs-directory "autosaves/"))

 (unless (file-exists-p emacs-autosave-directory)
   (make-directory emacs-autosave-directory))

 (setq auto-save-file-name-transforms
	`((".*" ,emacs-autosave-directory t)))
 ;; backup
 (setq backup-directory-alist '(("." . "~/.emacs.d/backups"))
	kept-new-versions 10
	kept-old-versions 0
	delete-old-versions t
	backup-by-copying t
	vc-make-backup-files t)
 (setq delete-by-moving-to-trash t)
 ;; scratch buffer message
 (setq initial-scratch-message ";; Better to run than curse the road.\n")
 ;; scratch major mode
 (setq initial-major-mode 'emacs-lisp-mode)
 ;; save system clipboard contents to emacs kill ring
 (setq save-interprogram-paste-before-kill t)
 ;; change emacs frame title
 (setq frame-title-format
	'("" invocation-name ": " (:eval (replace-regexp-in-string
					  "^ +" "" (buffer-name)))))
 (use-package desktop
   :config
   (add-to-list 'desktop-globals-to-save 'register-alist)
   (setq desktop-lazy-verbose nil
	  desktop-restore-eager 15)
   (desktop-save-mode 1))

 ;; (use-package hl-line
 ;;   :init
 ;;   (add-hook 'prog-mode-hook (lambda () (hl-line-mode t)))
 ;;   (add-hook 'text-mode-hook (lambda () (hl-line-mode t))))
 ;; text-scale
 (defhydra hydra-text-scale ()
   "text-scale"
   ("i" text-scale-increase "in")
   ("o" text-scale-decrease "out")
   ("r" (text-scale-set 0) "reset")
   ("q" nil "quit"))
 (my/leader-keys
   "xz" 'hydra-text-scale/body)

 ;; window-scale
 (defhydra hydra-window-scale ()
   "window-scale"
   ("i" (lambda () (interactive) (enlarge-window-horizontally 10)) "in")
   ("o" (lambda () (interactive) (shrink-window-horizontally 10)) "out")
   ("I" (lambda () (interactive) (enlarge-window 5)) "IN")
   ("O" (lambda () (interactive) (shrink-window 5)) "OUT")
   ("r" balance-windows "reset")
   ("q" nil "quit"))
 (my/leader-keys
   "wz" 'hydra-window-scale/body)

 ;; build-in modes
 (use-package eldoc
   :ghook ('(emacs-lisp-mode-hook
	      lisp-interaction-mode-hook
	      ielm-mode-hook
	      eval-expression-minibuffer-setup-hook)))

 (use-package display-line-numbers
   :if (version<= "26.1" emacs-version)
   :ghook ('after-init-hook #'global-display-line-numbers-mode)
   :general
   (my/leader-keys
     "tl" 'my/toggle-line-numbers-type)
   :config
   (setq display-line-numbers-type 'visual)
 ;;;###autoload
   (defun my/toggle-line-numbers-type ()
     (interactive)
     (if (eq display-line-numbers t)
	  (progn
	    (setq display-line-numbers 'visual)
	    (message "show visual line numbers"))
	(progn
	  (setq display-line-numbers t)
	  (message "Show absolute line numbers")))))

 (use-package prettify-symbols-mode
   :ensure nil
   :ghook ('after-init-hook #'global-prettify-symbols-mode)
   :init
   (setq prettify-symbols-unprettify-at-point 'right-edge))

 (use-package recentf
   :ensure nil
   :init
   (add-hook 'find-file-hook (lambda () (unless recentf-mode
						 (recentf-mode)
						 (recentf-track-opened-file))))
   :config
   (progn
     (setq recentf-max-saved-items 2000
	    recentf-auto-cleanup 'never
	    recentf-exclude '("/.emacs.d/pyim/" "/.elfeed/"))
     (recentf-mode 1)))

 (use-package autorevert
   :ensure nil
   :diminish auto-revert-mode
   :config
   (setq auto-revert-interval 0.5)
   (global-auto-revert-mode))

 (use-package server
   :ensure nil
   :ghook ('after-init-hook #'server-start))

 (use-package winner
   :ensure nil
   :init
   (my/leader-keys
     "wu" 'winner-undo
     "wU" 'winner-redo)
   :config
   (setq winner-boring-buffers
	  '("*Completions*"
	    "*Compile-Log*"
	    "*inferior-lisp*"
	    "*Fuzzy Completions*"
	    "*Apropos*"
	    "*Help*"
	    "*cvs*"
	    "*Buffer List*"
	    "*Ibuffer*"
	    "*esh command on file*"
	    "*Youdao Dictionary*"
	    "*PDF-Occur*"
	    "*Google Translate*"
	    "*magit.*"
	    ))
   (winner-mode))

 (use-package savehist
   :ensure nil
   :config
   (progn
     (setq savehist-autosave-interval 10)
     (savehist-mode 1)
     ;; save shell history https://oleksandrmanzyuk.wordpress.com/2011/10/23/a-persistent-command-history-in-emacs/
     (defun comint-write-history-on-exit (process event)
	"Write comint history of PROCESS when EVENT happened to a file specified in buffer local var 'comint-input-ring-file-name' (defined in turn-on-comint-history)."
	(comint-write-input-ring)
	(let ((buf (process-buffer process)))
	  (when (buffer-live-p buf)
	    (with-current-buffer buf
	      (insert (format "\nProcess %s %s" process event))))))
     (defun turn-on-comint-history ()
	"Setup comint history.
 When comint process started set buffer local var
 'comint-input-ring-file-name', so that a file name is specified to write
 and read from comint history.

 That 'comint-input-ring-file-name' is buffer local is determined by the
 4th argument to 'add-hook' below.  And localness is important, because
 otherwise 'comint-write-input-ring' will find mentioned var nil."
	(let ((process (get-buffer-process (current-buffer))))
	  (when process
	    (setq comint-input-ring-file-name
		  (format "~/.emacs.d/inferior-%s-history"
			  (process-name process)))
	    (comint-read-input-ring)
	    (set-process-sentinel process
				  #'comint-write-history-on-exit))))
     (defun mapc-buffers (fn)
	(mapc (lambda (buffer)
		(with-current-buffer buffer
		  (funcall fn)))
	      (buffer-list)))
     (defun comint-write-input-ring-all-buffers ()
	(mapc-buffers 'comint-write-input-ring))
     (add-hook 'inferior-python-mode-hook 'turn-on-comint-history nil nil)
     (add-hook 'kill-buffer-hook 'comint-write-input-ring)
     (add-hook 'kill-emacs-hook 'comint-write-input-ring-all-buffers)))

 (use-package ispell
   :ensure nil
   :config
   (progn
     (setq ispell-program-name "aspell"
	    ispell-silently-savep t
	    ispell-look-command "/bin/grep"
	    ispell-look-options "-Ei")))

 (defun my/ispell-lookup-words (word &optional lookup-dict)
   "Look up WORD in optional word-list dictionary LOOKUP-DICT.
 A `*' serves as a wild card.  If no wild cards, `look' is used if it exists.
 Otherwise the variable `ispell-grep-command' contains the command
 \(usually \"grep\") used to search for the words.

 Optional second argument contains the dictionary to use; the default is
 `ispell-alternate-dictionary', overridden by `ispell-complete-word-dict'
 if defined."
   ;; We don't use the filter for this function, rather the result is written
   ;; into a buffer.  Hence there is no need to save the filter values.
   (if (null lookup-dict)
	(setq lookup-dict (or ispell-complete-word-dict
			      ispell-alternate-dictionary)))

   (if lookup-dict
	(unless (file-readable-p lookup-dict)
	  (error "lookup-words error: Unreadable or missing plain word-list %s."
		 lookup-dict))
     (error (concat "lookup-words error: No plain word-list found at system"
		     "default locations.  "
		     "Customize `ispell-alternate-dictionary' to set yours.")))

   (let* ((process-connection-type ispell-use-ptys-p)
	   (wild-p (string-match "\\*" word))
	   (look-p (and ispell-look-p	; Only use look for an exact match.
			(or ispell-have-new-look (not wild-p))))
	   (prog (if look-p ispell-look-command ispell-grep-command))
	   (args (if look-p ispell-look-options ispell-grep-options))
	   status results loc)
     (with-temp-buffer
	;; (message "Starting \"%s\" process..." (file-name-nondirectory prog))
	(if look-p
	    nil
	  (insert "^" word)
	  ;; When there are no wildcards, append one, for consistency
	  ;; with `look' behavior.
	  (unless wild-p (insert "*"))
	  (insert "$")
	  ;; Convert * to .*
	  (while (search-backward "*" nil t) (insert "."))
	  (setq word (buffer-string))
	  (erase-buffer))
	(setq status (apply 'ispell-call-process prog nil t nil
			    (nconc (if (and args (> (length args) 0))
				       (list args)
				     (if look-p nil
				       (list "-e")))
				   (list word)
				   (if lookup-dict (list lookup-dict)))))
	;; `grep' returns status 1 and no output when word not found, which
	;; is a perfectly normal thing.
	(if (stringp status)
	    (error "error: %s exited with signal %s"
		   (file-name-nondirectory prog) status)
	  ;; Else collect words into `results' in FIFO order.
	  (goto-char (point-max))
	  ;; Assure we've ended with \n.
	  (or (bobp) (= (preceding-char) ?\n) (insert ?\n))
	  (while (not (bobp))
	    (setq loc (point))
	    (forward-line -1)
	    (push (buffer-substring-no-properties (point)
						  (1- loc))
		  results))))
     (if (and results (string-match ".+: " (car results)))
	  (error "%s error: %s" ispell-grep-command (car results)))
     results))

 (advice-add 'ispell-lookup-words :override #'my/ispell-lookup-words)

 (use-package calendar
   :ensure nil
   :commands calendar
   :config
   ;; keybindings are copied from evil-collection
   (my/normal-keys
     :keymaps 'calendar-mode-map
     ;; motion
     "h" 'calendar-backward-day
     "j" 'calendar-forward-week
     "k" 'calendar-backward-week
     "l" 'calendar-forward-day
     "0" 'calendar-beginning-of-week
     "^" 'calendar-beginning-of-week
     "$" 'calendar-end-of-week
     "[" 'calendar-backward-year
     "]" 'calendar-forward-year
     "M-<" 'calendar-beginning-of-year
     "M->" 'calendar-end-of-year
     "(" 'calendar-beginning-of-month
     ")" 'calendar-end-of-month
     "<" 'calendar-scroll-right
     ">" 'calendar-scroll-left
     "C-b" 'calendar-scroll-right-three-months
     "C-f" 'calendar-scroll-left-three-months
     "{" 'calendar-backward-month
     "}" 'calendar-forward-month
     "C-k" 'calendar-backward-month
     "C-j" 'calendar-forward-month
     "gk" 'calendar-backward-month
     "gj" 'calendar-forward-month

     ;; visual
     "v" 'calendar-set-mark

     ;; goto
     "." 'calendar-goto-today
     "gd" 'calendar-goto-date ; "gd" in evil-org-agenda, "gd" in Emacs.
     ;; "gD" 'calendar-other-month ; Not very useful if we have `calendar-goto-date'.

     ;; diary
     "D" 'diary-view-other-diary-entries
     "d" 'diary-view-entries
     "m" 'diary-mark-entries
     "s" 'diary-show-all-entries

     "u" 'calendar-unmark
     "x" 'calendar-mark-holidays

     ;; show
     "gm" 'calendar-lunar-phases ; "gm" in evil-org-agenda.
     "gs" 'calendar-sunrise-sunset ; "gs" in evil-org-agenda
     "gh" 'calendar-list-holidays ; "gh" in evil-org-agenda.
     "ga" 'org-calendar-goto-agenda ; "gc" in evil-org-agenda.
     "r" 'calendar-cursor-holidays

     ;; refresh
     "gr" 'calendar-redraw

     "g?" 'calendar-goto-info-node
     "?" 'calendar-goto-info-node ; Search is not very useful.
     "M-=" 'calendar-count-days-region

     ;; quit
     "q" 'calendar-exit))

 (use-package imenu
   :ensure nil
   :general
   (my/leader-keys
     "ji" 'imenu))

 (use-package image-mode
   :ensure nil
   :mode (".jpg\\'" . image-mode)
   :config
   (progn
     (add-hook 'image-mode-hook (lambda() (display-line-numbers-mode -1)))
     (setq image-animate-loop t)
     (my/leader-keys-major-mode
	:keymaps 'image-mode-map
	"aa" 'image-toggle-animation
	"a+" 'image-increase-speed
	"a-" 'image-decrease-speed
	"ar" 'image-reset-speed
	"gn" 'image-next-file
	"gN" 'image-previous-file
	"t+" 'image-increase-size
	"t-" 'image-decrease-size
	"tf" 'image-mode-fit-frame
	"tr" 'image-transform-reset
	"th" 'image-transform-fit-to-height
	"tw" 'image-transform-fit-to-width
	"ts" 'image-transform-set-scale
	"tr" 'image-transform-rotation)
     (my/leader-keys-major-mode
	:keymaps 'image-mode-map
	:major-modes t
	"a" '(:ignore t :wk "animate")
	"g" '(:ignore t :wk "goto file")
	"t" '(:ignore t :wk "transform/resize"))
     (my/normal-keys
	:keymaps 'image-mode-map
	"h" 'image-backward-hscroll
	"j" 'image-next-line
	"k" 'image-previous-line
	"l" 'image-forward-hscroll)))

 (use-package saveplace
   :ensure nil
   :config
   (save-place-mode))

 (use-package custom
   :ensure nil
   :general
   (my/normal-keys
     :keymaps 'custom-mode-map
     "n" 'widget-forward
     "p" 'widget-backward
     "C-o" 'Custom-goto-parent
     "q" 'Custom-buffer-done))

 (use-package midnight
   :init
   (add-hook 'midnight-hook #'recentf-cleanup)
   :config
   (setq clean-buffer-list-kill-regexps '("^.*")
	  midnight-period 7200
	  clean-buffer-list-delay-special 259200)
   (midnight-mode 1))

 (use-package find-file
   :ensure nil
   :init
   (my/leader-keys
     "fO" 'ff-find-other-file)
   (defvar org-other-file-alist
     '(("\\.org\\'" (".el" ".pdf"))))
   (defvar el-other-file-alist
     '(("\\.el\\'" (".org"))))
   (defvar pdf-other-file-alist
     '(("\\.pdf\\'" (".tex" ".org"))))
   (defvar latex-other-file-alist
     '(("\\.tex\\'" (".pdf"))))
   (add-hook 'org-mode-hook
	      (lambda () (setq ff-other-file-alist 'org-other-file-alist)))
   (add-hook 'emacs-lisp-mode-hook
	      (lambda () (setq ff-other-file-alist 'el-other-file-alist)))
   (add-hook 'LaTeX-mode-hook
	      (lambda () (setq ff-other-file-alist 'latex-other-file-alist)))
   (add-hook 'pdf-view-mode-hook
	      (lambda () (setq ff-other-file-alist 'pdf-other-file-alist))))

 (use-package replace
   :ensure nil
   :general
   (my/normal-keys
     :keymaps 'occur-mode-map
     "RET" 'occur-mode-goto-occurrence-other-window
     "q" 'quit-window))
 ;; key bindings

 (my/all-states-keys
   "C-e" 'move-end-of-line)

 (my/leader-keys
   "!" 'shell-command)

 ;; Universal argument
 (my/leader-keys
   "u" 'universal-argument)

 ;; applications --------------------------------------------------------------
 (my/leader-keys
   ;; "au" 'undo-tree-visualize
   "ac" 'calendar
   "at" 'my/show-current-time
   "aP" 'list-processes)
 ;; buffer --------------------------------------------------------------------
 (my/leader-keys
   "bd" 'my/kill-this-buffer
   "bn" 'next-buffer
   "bp" 'previous-buffer
   "br" 'revert-buffer
   "TAB" 'my/alternate-buffer
   "bx" 'kill-buffer-and-window
   )
 ;; file ----------------------------------------------------------------------
 (my/leader-keys
   "fs" 'save-buffer
   "fn" 'my/copy-file-name-to-clipboard)
 ;; frame
 (my/leader-keys
   "Fd" 'delete-frame
   "Fn" 'make-frame
   "Fo" 'other-frame)
 ;; help ----------------------------------------------------------------------
 (my/leader-keys
   "hdb" 'describe-bindings
   "hdc" 'describe-char
   "hdf" 'describe-function
   "hdk" 'describe-key
   "hdm" 'describe-mode
   "hdp" 'describe-package
   "hdt" 'describe-theme
   "hdv" 'describe-variable
   "hn"  'view-emacs-news
   )
 ;; quit ---------------------------------------------------------------------
 (my/leader-keys
   "qs" 'save-buffers-kill-emacs
   "qr" 'restart-emacs
   "qd" 'my/restart-emacs-debug-init)
 ;; window -------------------------------------------------------------------
 (my/leader-keys
   "wv" 'split-window-right
   "wV" 'my/split-window-right-and-focus
   "ws" 'split-window-below
   "wS" 'my/split-window-below-and-focus
   "w=" 'balance-windows-area
   "wb" 'balance-windows
   "wm" 'my/toggle-maximize-buffer
   "wd" 'delete-window)
 ;; text
 (my/leader-keys
   "xp" 'clipboard-yank
   "xy" 'clipboard-kill-ring-save
   "xc" 'clipboard-kill-region)
 ;; frequently accessed files
 (defhydra hydra-frequently-accessed-files (:exit t)
   "files"
   ("a" (lambda () (interactive) (find-file "~/Dropbox/document/org/appts/appts.org")) "appts.org")
   ("o" (lambda () (interactive) (find-file "~/Dropbox/document/org/main.org")) "main.org")
   ("n" (lambda () (interactive) (find-file "~/Dropbox/document/org/references/ref-notes.org")) "ref-noter.org")
   ("i" (lambda () (interactive) (find-file "~/.emacs.d/init.el")) "init.el")
   ("l" (lambda () (interactive) (find-file "~/Dropbox/document/ledger/ledger.ledger")) "ledger.ledger")
   ("d" (lambda () (interactive) (find-file "~/.dotfiles/README.md")) "dotfiles")
   ("M-d" (lambda () (interactive) (deer "~/Dropbox/")) "Dropbox")
   ("c" (lambda () (interactive) (find-file "~/Dropbox/document/org/capture/capture.org")) "capture.org")
   ("q" nil "quit"))
 (my/leader-keys
   "fo" 'hydra-frequently-accessed-files/body)

 ;;;###autoload
 (defun my/split-window-right-and-focus ()
   "Split the window horizontally and focus the new window."
   (interactive)
   (split-window-right)
   (windmove-right)
   (when (and (boundp 'golden-ratio-mode)
	       (symbol-value golden-ratio-mode))
     (golden-ratio)))

 ;;;###autoload
 (defun my/split-window-below-and-focus ()
   "Split the window vertically and focus the new window."
   (interactive)
   (split-window-below)
   (windmove-down)
   (when (and (boundp 'golden-ratio-mode)
	       (symbol-value golden-ratio-mode))
     (golden-ratio)))

(defun my/defer-garbage-collection ()
  (setq gc-cons-threshold most-positive-fixnum))

(defun my/restore-garbage-collection ()
  (setq gc-cons-threshold 800000))

(add-hook 'minibuffer-setup-hook #'my/defer-garbage-collection)
(add-hook 'minibuffer-exit-hook #'my/restore-garbage-collection)

 (use-package esup
   :commands esup
   :init
   (progn
     (my/leader-keys
	"ae" 'esup))
   :config
   (my/motion-keys
     :keymaps 'esup-mode-map
     "n" 'esup-next-result
     "p" 'esup-previous-result))

 (use-package benchmark-init
   :commands (benchmark-init/show-durations-tree
	       benchmark-init/durations-tree)
   :init
   (progn
     (my/leader-keys
	"ab" '(:ignore t :which-key "benchmark")
	"abt" 'benchmark-init/show-durations-tabulated
	"abr" 'benchmark-init/show-durations-tree))
   :config
   ;; To disable collection of benchmark data after init is done.
   (add-hook 'after-init-hook 'benchmark-init/deactivate))

;; Suppress GUI features
(setq use-file-dialog nil)
(setq use-dialog-box nil)
(setq inhibit-startup-screen t)
(setq inhibit-startup-echo-area-message t)

;; Show a marker in the left fringe for lines not in the buffer
(setq-default indicate-empty-lines t)

(use-package beacon
  :diminish beacon-mode
  :config
  (setq beacon-blink-when-window-scrolls nil
	  beacon-dont-blink-major-modes '(t pdf-view-mode)
	  beacon-size 10)
  (beacon-mode 1))

(use-package rainbow-delimiters
  :commands rainbow-delimiters-mode
  :init
  (add-hook 'prog-mode-hook 'rainbow-delimiters-mode)
  (add-hook 'text-mode-hook 'rainbow-delimiters-mode))

(use-package highlight-parentheses
  :diminish highlight-parentheses-mode
  :ghook ('prog-mode-hook #'highlight-parentheses-mode)
  :config
  (setq hl-paren-delay 0.2)
  (setq hl-paren-colors '("Springgreen3"
			    "IndianRed1"
			    "IndianRed3"
			    "IndianRed4"))
  (set-face-attribute 'hl-paren-face nil :weight 'ultra-bold))

(use-package highlight-indentation
    :diminish highlight-indentation-mode
    :commands highlight-indentation-mode
    :init
    (add-hook 'prog-mode-hook #'highlight-indentation-mode))

(use-package highlight-numbers
  :commands highlight-numbers-mode
  :init
  (add-hook 'prog-mode-hook 'highlight-numbers-mode))

(use-package highlight-symbol
  :diminish highlight-symbol-mode
  :general
  (my/leader-keys
    "tha" 'my/toggle-highlight-symbol
    "sh" 'highlight-symbol-at-point
    "sr" 'highlight-symbol-remove-all)
  (:states '(normal visual motion)
   "M-]" 'highlight-symbol-next
   "M-[" 'highlight-symbol-prev
   "M-'" 'highlight-symbol-query-replace)
  :config
  (setq highlight-symbol-idle-delay 0.5
	  highlight-symbol-occurrence-message '(explicit nivigation temporary)))

(use-package color-identifiers-mode
  :diminish color-identifiers-mode
  :commands color-identifiers-mode
  :general
  (my/leader-keys
    "thi" 'my/toggle-color-identifiers))

(use-package which-key
  :diminish which-key-mode
  :config
  (progn
    (setq which-key-idle-secondary-delay 0
	    which-key-sort-order 'which-key-key-order-alpha)
    (my/leader-keys
     "a" '(:ignore t :which-key "applications")
     "ao" '(:ignore t :which-key "org")
     "aof" '(:ignore t :which-key "feed")
     "aok" '(:ignore t :which-key "clock")
     "b" '(:ignore t :which-key "buffers")
     "c" '(:ignore t :which-key "comments")
     "C" '(:ignore t :which-key "Capture")
     "e" '(:ignore t :which-key "errors")
     "f" '(:ignore t :which-key "files")
     "F" '(:ignore t :which-key "Frames")
     "g" '(:ignore t :which-key "git/vc")
     "gf" '(:ignore t :which-key "files")
     "h" '(:ignore t :which-key "help")
     "i" '(:ignore t :which-key "insert")
     "iS" '(:ignore t :which-key "auto-yas")
     "j" '(:ignore t :which-key "jump")
     "p" '(:ignore t :which-key "projects")
     "ps" '(:ignore t :which-key "search")
     "q" '(:ignore t :which-key "quit")
     "r" '(:ignore t :which-key "regs/rings/replace")
     "s" '(:ignore t :which-key "search")
     "M-s" '(:ignore t :which-key "Spell/Grammar")
     "t" '(:ignore t :which-key "toggles")
     "th" '(:ignore t :which-key "highlight")
     "T" '(:ignore t :which-key "Themes")
     "w" '(:ignore t :which-key "windows")
     "wp" '(:ignore t :which-key "popwin")
     "x" '(:ignore t :which-key "text")
     "xS" '(:ignore t :which-key "Synosaurus")
     "z" '(:ignore t :which-key "zoom"))
    (which-key-mode)))

(use-package which-key-posframe
  :if (and (window-system) (version<= "26.1" emacs-version))
  :after (which-key posframe)
  :config
  (setq which-key-posframe-border-width 2)
  (which-key-posframe-mode))

 (use-package popwin
     :config
     (progn
	(my/leader-keys
	 "wpm" 'popwin:messages
	 "wpp" 'popwin:close-popup-window)
	(popwin-mode 1)
	;; don't use default value but manage it ourselves
	(setq popwin:special-display-config nil)

	;; buffers that we manage
	(push '("*Help*"                 :dedicated t :position bottom :stick t :noselect nil   :height 0.4) popwin:special-display-config)
	(push '("*Process List*"         :dedicated t :position bottom :stick t :noselect nil :height 0.4) popwin:special-display-config)
	(push '("*compilation*"          :dedicated t :position bottom :stick t :noselect t   :height 0.4) popwin:special-display-config)
	(push '("*Shell Command Output*" :dedicated t :position bottom :stick t :noselect nil            ) popwin:special-display-config)
	(push '("*Async Shell Command*"  :dedicated t :position bottom :stick t :noselect nil            ) popwin:special-display-config)
	(push '(" *undo-tree*"           :dedicated t :position right  :stick t :noselect nil :width   60) popwin:special-display-config)
	(push '("*undo-tree Diff*"       :dedicated t :position bottom :stick t :noselect nil :height 0.3) popwin:special-display-config)
	(push '("*ert*"                  :dedicated t :position bottom :stick t :noselect nil            ) popwin:special-display-config)
	(push '("*grep*"                 :dedicated t :position bottom :stick t :noselect nil            ) popwin:special-display-config)
	(push '("*nosetests*"            :dedicated t :position bottom :stick t :noselect nil            ) popwin:special-display-config)
	(push '("^\*WoMan.+\*$" :regexp t             :position bottom                                   ) popwin:special-display-config)
	(push '("*Google Translate*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.4) popwin:special-display-config)
	(push '("*frequencies*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.4) popwin:special-display-config)
	(push '("*Synonyms List*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.4) popwin:special-display-config)
	(push '("*Ledger Report*"     :dedicated t :position right :stick t :noselect nil   :width 0.6) popwin:special-display-config)
	(push '("\*Outline.*\*"     :regexp t :dedicated t :position right :stick t :noselect nil   :width 0.3) popwin:special-display-config)
	(push '("*PDF-Occur*"     :dedicated t :position right :stick t :noselect nil   :width 0.4) popwin:special-display-config)
	(push '("*WordNut*"     :dedicated t :position right :stick t :noselect nil   :width 0.5) popwin:special-display-config)
	(push '("*Synonyms List*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.4) popwin:special-display-config)
	(push '("*Calendar*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.4) popwin:special-display-config)
	(push '("*Youdao Dictionary*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.25) popwin:special-display-config)
	(push '("*Anaconda*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.25) popwin:special-display-config)
	(push '(flycheck-error-list-mode     :dedicated t :position bottom :stick t :noselect nil   :height 0.25) popwin:special-display-config)
	(push '("*Compile-Log*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.25) popwin:special-display-config)
	(push '("*Apropos*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.25) popwin:special-display-config)
	(push '("*TeX Help*"     :dedicated t :position bottom :stick t :noselect nil   :height 0.25) popwin:special-display-config)
	))

(use-package zoom-frm
  :commands (zoom-frm-unzoom
	       zoom-frm-out
	       zoom-frm-in)
  :init
  (progn
    (defhydra hydra-zoom-frm ()
	 "zoom-frm"
	 ("i" zoom-frm-in "in")
	 ("o" zoom-frm-out "out")
	 ("0" zoom-frm-unzoom "reset")
	 ("q" nil "quit")
	 )
    (my/leader-keys
     "Fz" 'hydra-zoom-frm/body)))

(use-package hide-mode-line
  :commands my/toggle-hide-mode-line
  :init
  (my/leader-keys
    "tm" 'my/toggle-hide-mode-line))

;;;###autoload
(defun my/toggle-hide-mode-line ()
  (interactive)
  (hide-mode-line-mode (if hide-mode-line-mode -1 +1))
  (unless hide-mode-line-mode
    (redraw-display)))

(use-package window-purpose
  :ghook ('after-init-hook #'purpose-mode)
  :general
  (my/leader-keys
    "rb"    'purpose-switch-buffer-with-purpose
    "rB"    'switch-buffer-without-purpose
    "rd"    'purpose-toggle-window-purpose-dedicated
    "r M-d" 'purpose-toggle-window-buffer-dedicated
    "rD"    'purpose-delete-non-dedicated-windows
    "rl"    'purpose-load-window-layout
    "rp"    'purpose-switch-buffer-with-some-purpose
    "rP"    'purpose-set-window-purpose
    "rf"    'purpose-load-window-layout-file)
  :config
  (setq purpose-default-layout-file (concat user-emacs-directory "layouts")
	  default-file-purpose 'general)
  (add-to-list 'purpose-user-mode-purposes '(python-mode . py))
  (add-to-list 'purpose-user-mode-purposes '(inferior-python-mode . py-repl))
  (add-to-list 'purpose-user-mode-purposes '(org-mode . org))
  (add-to-list 'purpose-user-mode-purposes '(pdf-view-mode . pdf))
  (global-set-key [remap ivy-switch-buffer] 'my/ivy-switch-buffer)
  (purpose-compile-user-configuration)
  (defalias 'ranger-find-file-without-purpose
    (without-purpose-command #'ranger-find-file))

(global-set-key [remap ranger-find-file] #'ranger-find-file-without-purpose))

;;;###autoload
(defun my/ivy-switch-buffer ()
  (interactive)
  (without-purpose (ivy-switch-buffer)))

;;;###autoload
(defun my/ranger-close ()
  (interactive)
  (without-purpose (ranger-close)))

(global-set-key [remap ranger-close] 'my/ranger-close)

(use-package spacemacs-purpose-popwin
  :ensure nil
  :load-path "site-lisp/spacemacs-purpose-popwin/"
  :after window-purpose
  :config
  (pupo-mode))

 (use-package spaceline-config
   :ensure spaceline
   :init
   (progn
     (setq spaceline-highlight-face-func 'spaceline-highlight-face-evil-state
	    powerline-default-separator 'slant
	    spaceline-purpose-hide-if-not-dedicated t
	    spaceline-window-numbers-unicode nil
	    spaceline-workspace-numbers-unicode nil
	    winum-auto-setup-mode-line nil
	    anzu-cons-mode-line-p nil))
   :config
   (spaceline-compile)
   (spaceline-helm-mode t)
   (spaceline-toggle-buffer-encoding-off)
   (spaceline-toggle-minor-modes-off)
   (spaceline-toggle-buffer-encoding-abbrev-off)
   (spaceline-toggle-major-mode-off)
   (spaceline-toggle-input-method-off)
   (spaceline-define-segment my/pomodoro
     (when (featurep 'pomodoro)
	pomodoro-mode-line-string))
   (spaceline-spacemacs-theme '(my/pomodoro :when active :tight t)))

 (setq winum-auto-setup-mode-line nil
	eyebrowse-mode-line-left-delimiter ""
	eyebrowse-mode-line-right-delimiter "")
 (defun my--pdfview-page-number ()
   (format "(%d/%d)"
	    (eval `(pdf-view-current-page))
	    (pdf-cache-number-of-pages)))

 (defvar my--mode-line-line-column
   '(:eval (if (eq major-mode 'pdf-view-mode)
		(my--pdfview-page-number)
	      (if (and
		   (boundp 'column-number-indicator-zero-based)
		   (not column-number-indicator-zero-based))
		  "(%l:%2c)"
		"(%l:%2c)"))))

 (defvar my--window-purpose
   '(:eval (when (and (bound-and-true-p purpose-mode)
		       (or (purpose-window-purpose-dedicated-p)
			   (window-dedicated-p)))
	      (propertize (substring (purpose--modeline-string) 2 -1)))))

 (defvar my--mode-line-pomodoro
   '(:eval
     (if (eq my--selected-window (selected-window))
	  `,pomodoro-mode-line-string)))

 (defvar my--mode-line-eyebrowse
   '(:eval (eyebrowse-mode-line-indicator)))

 (defvar my--mode-line-winum
   '(:eval (winum-get-number-string)))

 (defvar my--mode-line-evil-tag
   '(:eval evil-mode-line-tag))

 (setq-default mode-line-format
   (list
    mode-line-front-space
    "["
    my--mode-line-eyebrowse
    "|"
    my--mode-line-winum
    "]"
    " %*"
    my--mode-line-evil-tag
     ;; the buffer name
    "%b "
     ;; line and column
    my--mode-line-line-column
    '(vc-mode vc-mode)
     mode-line-process
     ;;global-mode-string, org-timer-set-timer in org-mode need this
     "%M"
     my--window-purpose
     " "
     my--mode-line-pomodoro
     ))

 (defvar my--selected-window nil)

 (defun my--record-selected-window ()
   (setq my--selected-window (selected-window)))

 (defun my--update-all ()
   (force-mode-line-update t))

 (add-hook 'post-command-hook 'my--record-selected-window)

 (add-hook 'buffer-list-update-hook 'my--update-all)

(use-package rainbow-mode
  :commands rainbow-mode
  :init
  (my/leader-keys
    "tc" 'rainbow-mode))

(use-package pretty-hydra
  :init
  (my/leader-keys
    "t." 'hydra-toggles/body)
  :config
  (pretty-hydra-define hydra-toggles
  (:hint nil :color amaranth :quit-key "q")
  ("Basic"
   (("n" display-line-numbers-mode "line number" :toggle t)
    ("N" my/toggle-line-numbers-type "line number type")
    ("L" linum-mode "Exact line number" :toggle t)
    ("w" whitespace-mode "whitespace" :toggle t)
    ("r" rainbow-mode "rainbow" :toggle t))
   "Highlight"
   (("S" highlight-symbol-mode "symbol" :toggle t)
    ("l" hl-line-mode "line" :toggle t)
    ("t" hl-todo-mode "todo" :toggle t)
    ("i" color-identifiers-mode "identifiers" :toggle t))
   "UI"
   (("m" hide-mode-line-mode "mode line" :toggle t))
   "Coding"
   (("p" smartparens-global-mode "smartparens" :toggle t)
    ("P" smartparens-global-strict-mode "smartparens strict" :toggle t)
    ("c" flycheck-mode "flycheck" :toggle t)
    ("s" flyspell-mode "flyspell" :toggle t)))))

(use-package all-the-icons
  :init
  (add-hook 'after-init-hook (lambda () (require 'all-the-icons)))
  :config
  (setq all-the-icons-scale-factor 1.0))

 (use-package all-the-icons-ivy
   :after (ivy all-the-icons)
   :init
   (add-hook 'counsel-projectile-mode-hook 'all-the-icons-ivy-setup)
   (add-hook 'ivy-mode-hook 'all-the-icons-ivy-setup)
   :config
   (progn
     (defun all-the-icons-ivy-file-transformer (s)
	"Return a candidate string for filename S preceded by an icon."
	(format "%s %s"
		(propertize "\t" 'display (all-the-icons-ivy-icon-for-file s))
		s))
     (defun all-the-icons-ivy--buffer-transformer (b s)
	"Return a candidate string for buffer B named S preceded by an icon.
 Try to find the icon for the buffer's B `major-mode'.
 If that fails look for an icon for the mode that the `major-mode' is derived from."
	(let ((mode (buffer-local-value 'major-mode b)))
	  (format "%s %s"
		  (propertize "\t" 'display (or
					     (all-the-icons-ivy--icon-for-mode mode)
					     (all-the-icons-ivy--icon-for-mode (get mode 'derived-mode-parent))))
		  (all-the-icons-ivy--buffer-propertize b s))))
     (all-the-icons-ivy-setup)))

(use-package all-the-icons-dired
  :after ranger
  :init
  (add-hook 'ranger-mode-hook 'all-the-icons-dired-mode)
  (add-hook 'dired-mode-hook 'all-the-icons-dired-mode))

(use-package hl-todo
  :commands hl-todo-mode
  :init
  (add-hook 'prog-mode-hook 'hl-todo-mode)
  (add-hook 'LaTeX-mode-hook 'hl-todo-mode))

(use-package restart-emacs
  :config
  (setq restart-emacs-restore-frame t)
  :general
  (my/leader-keys
    "qr" 'restart-emacs))

 (use-package undo-tree
   :ghook ('after-init-hook #'global-undo-tree-mode)
   :diminish undo-tree-mode
   :general
   (my/leader-keys
     "au" 'undo-tree-visualize)
   (my/normal-keys
     "U" 'undo-tree-redo)
   :config
   (progn
     (setq undo-tree-visualizer-timestamps t
	    undo-tree-visualizer-diff t
	    undo-tree-auto-save-history t
	    undo-tree-history-directory-alist '(("." . "~/.emacs.d/undo")))
     (defun spacemacs/undo-tree-restore-default ()
	(setq undo-tree-visualizer-diff t))
     (advice-add 'undo-tree-visualizer-quit :after #'spacemacs/undo-tree-restore-default)))

(use-package undo-fu
  :general
  (my/normal-keys
    "U" 'undo-fu-only-redo)
  :config
  (global-undo-tree-mode -1))

(use-package undo-fu-session
  :config
  (setq undo-fu-session-incompatible-files '("/COMMIT_EDITMSG\\'" "/git-rebase-todo\\'"))
  (global-undo-fu-session-mode))

 (use-package expand-region
     :general
     (my/leader-keys
      "v" 'er/expand-region)
     :config
     (progn
	(setq expand-region-contract-fast-key "V"
	      expand-region-reset-fast-key "r")))

(use-package sudo-edit
  :general
  (my/leader-keys
    "fe" 'sudo-edit))

 (use-package smartparens
   :diminish smartparens-mode
   :config
   (smartparens-global-mode t)
   (smartparens-global-strict-mode t)
   ;; :init
   ;; smartparens #431 workaround for fixing conflict between smarparens and yasnippet
   (add-hook 'yas-before-expand-snippet-hook (lambda () (smartparens-mode -1)))
   (add-hook 'yas-after-exit-snippet-hook (lambda () (smartparens-mode 1)))
   (my/leader-keys
     "k{" 'sp-wrap-curly
     "k(" 'sp-wrap-round
     "k[" 'sp-wrap-square
     "ku" 'sp-unwrap-sexp
     "kr" 'sp-rewrap-sexp
     "tp" 'my/toggle-smartparens)
   (my/all-states-keys
     :prefix "M-s"
     "." 'hydra-smartparens/body
     ;; Moving
     "a" 'sp-beginning-of-sexp
     "e" 'sp-end-of-sexp
     "f" 'sp-forward-sexp
     "b" 'sp-backward-sexp
     "n" 'sp-down-sexp
     "N" 'sp-backward-down-sexp
     "p" 'sp-up-sexp
     "P" 'sp-backward-up-sexp

     ;; Slurping & barfing
     "h" 'sp-backward-slurp-sexp
     "H" 'sp-backward-barf-sexp
     "l" 'sp-forward-slurp-sexp
     "L" 'sp-forward-barf-sexp

     ;; Wrapping
     "R" 'sp-rewrap-sexp
     "u" 'sp-unwrap-sexp
     "U" 'sp-backward-unwrap-sexp
     "(" 'sp-wrap-round
     "{" 'sp-wrap-curly
     "[" 'sp-wrap-square
     "'" 'my/sp-wrap-single-quote
     "\"" 'my/sp-wrap-double-quote

     ;; Sexp juggling
     "S" 'sp-split-sexp
     "s" 'sp-splice-sexp
     "r" 'sp-raise-sexp
     "j" 'sp-join-sexp
     "t" 'sp-transpose-sexp
     "A" 'sp-absorb-sexp
     "E" 'sp-emit-sexp
     "o" 'sp-convolute-sexp

     ;; Destructive editing
     "c" 'sp-change-inner :exit t
     "C" 'sp-change-enclosing :exit t
     "k" 'sp-kill-sexp
     "K" 'sp-backward-kill-sexp
     "M-k" 'my/sp-kill-inside-sexp
     "w" 'sp-copy-sexp)
   (defun my/toggle-smartparens ()
     (interactive)
     (if (bound-and-true-p smartparens-mode)
	  (progn
	    (smartparens-mode -1)
	    (smartparens-strict-mode -1)
	    (evil-smartparens-mode -1)
	    (message "Smartparens mode disabled in current buffer"))
	(progn
	  (smartparens-mode 1)
	  (smartparens-strict-mode 1)
	  (evil-smartparens-mode 1)
	  (message "Smartparens mode enabled in current buffer"))))
   (defhydra hydra-smartparens (:hint nil)
     "
  Moving^^^^                       Slurp & Barf^^   Wrapping^^            Sexp juggling^^^^               Destructive
 ------------------------------------------------------------------------------------------------------------------------
  [_a_] beginning  [_n_] down      [_h_] bw slurp   [_R_] rewrap        [_S_] split   [_t_] transpose   [_c_] change inner  [_w_] copy
  [_e_] end        [_N_] bw down   [_H_] bw barf    [_u_] unwrap        [_s_] splice  [_A_] absorb      [_C_] change outer  [_M-k_] kill inside
  [_f_] forward    [_p_] up        [_l_] slurp      [_U_] bw unwrap     [_r_] raise   [_E_] emit        [_k_] kill          [_g_] quit
  [_b_] backward   [_P_] bw up     [_L_] barf       [_(__{__[__'__\"_] wrap      [_j_] join    [_o_] convolute   [_K_] bw kill       [_q_] quit"
     ;; Moving
     ("a" sp-beginning-of-sexp)
     ("e" sp-end-of-sexp)
     ("f" sp-forward-sexp)
     ("b" sp-backward-sexp)
     ("n" sp-down-sexp)
     ("N" sp-backward-down-sexp)
     ("p" sp-up-sexp)
     ("P" sp-backward-up-sexp)

     ;; Slurping & barfing
     ("h" sp-backward-slurp-sexp)
     ("H" sp-backward-barf-sexp)
     ("l" sp-forward-slurp-sexp)
     ("L" sp-forward-barf-sexp)

     ;; Wrapping
     ("R" sp-rewrap-sexp)
     ("u" sp-unwrap-sexp)
     ("U" sp-backward-unwrap-sexp)
     ("(" sp-wrap-round)
     ("{" sp-wrap-curly)
     ("[" sp-wrap-square)
     ("'" my/sp-wrap-single-quote)
     ("\"" my/sp-wrap-double-quote)

     ;; Sexp juggling
     ("S" sp-split-sexp)
     ("s" sp-splice-sexp)
     ("r" sp-raise-sexp)
     ("j" sp-join-sexp)
     ("t" sp-transpose-sexp)
     ("A" sp-absorb-sexp)
     ("E" sp-emit-sexp)
     ("o" sp-convolute-sexp)

     ;; Destructive editing
     ("c" sp-change-inner :exit t)
     ("C" sp-change-enclosing :exit t)
     ("k" sp-kill-sexp)
     ("K" sp-backward-kill-sexp)
     ("M-k" my/sp-kill-inside-sexp)
     ("w" sp-copy-sexp)

     ("q" nil)
     ("g" nil)))

 ;;;###autoload
 (defun my/sp-wrap-single-quote ()
   (interactive)
   (setq current-prefix-arg 0)
   (sp-wrap-with-pair "'"))

 ;;;###autoload
 (defun my/sp-wrap-double-quote ()
   (interactive)
   (setq current-prefix-arg 0)
   (sp-wrap-with-pair "\""))

 ;;;###autoload
 (defun my/sp-kill-inside-sexp ()
   "Kill inside of sexp."
   (interactive)
   (sp-kill-sexp 0))

 (advice-add 'sp-change-inner :after #'evil-insert-state)

(use-package evil-smartparens
  :after (evil smartparens)
  :diminish evil-smartparens-mode
  :init
  (add-hook 'smartparens-enabled-hook #'evil-smartparens-mode))

(use-package move-text
  :general
  (my/leader-keys
    "xJ" 'move-text-down
    "xK" 'move-text-up))

(use-package easy-kill
  :commands easy-kill
  :init
  (progn
    (global-set-key [remap kill-ring-save] 'easy-kill)))

(use-package zop-to-char
  :commands zop-to-char
  :general
  (my/all-states-keys
    "M-C-z" 'zop-to-char
    "M-z" 'zop-up-to-char)
  :config
  (progn
    (setq zop-to-char-prec-keys '(left ?\M-b)
	    zop-to-char-next-keys '(right ?\M-f))))

 (use-package imenu-list
   :commands imenu-list-smart-toggle
   :init
   (progn
     (setq imenu-list-focus-after-activation t
	    imenu-list-auto-resize t)
     (my/leader-keys
	;; "bi" 'imenu-list-smart-toggle
	"bi" 'my/imenu-list))
   :config
   (setq imenu-list-mode-line-format '("%e" (:eval (spaceline-ml-main))))
   (my/normal-keys
     :keymaps 'imenu-list-major-mode-map
     "d" 'imenu-list-display-entry
     "r" 'imenu-list-refresh
     "q" 'imenu-list-quit-window
     "RET" 'imenu-list-goto-entry))

 ;;;###autoload
 (defun my/imenu-list ()
   "Use lsp-ui-imenu if it's feasible, imenu-list-smart-toggle otherwise"
   (interactive)
   (if (bound-and-true-p lsp-mode)
	(lsp-ui-imenu)
     (imenu-list-smart-toggle)))

(use-package imenu-anywhere
  :general
  (my/leader-keys
    "jI" 'ivy-imenu-anywhere))

 (use-package string-inflection
   :general
   (my/leader-keys
     "xi" 'hydra-string-inflection/body)
   :config
   (progn
     (defhydra hydra-string-inflection ()
	"string inflection"
	("c" string-inflection-lower-camelcase "lower camel")
	("C" string-inflection-camelcase "camel")
	("k" string-inflection-kebab-case "kebab")
	("u" string-inflection-underscore "underscore")
	("U" string-inflection-upcase "upcase")
	("q" nil "quit"))))

(use-package unfill
  :commands (unfill-region unfill-paragraph unfill-toggle)
  :init
  (my/all-states-keys
    "M-q" 'unfill-toggle))

(use-package visual-fill-column
  :commands visual-fill-column-mode
  :config
  (add-hook 'visual-fill-column-mode-hook 'visual-line-mode))

(use-package fix-word
  :commands (fix-word-upcase
	       fix-word-downcase
	       fix-word-capitalize)
  :init
  (my/all-states-keys
    "M-u" 'fix-word-upcase
    "M-l" 'fix-word-downcase
    "M-c" 'fix-word-capitalize))

(use-package electric-operator
  :commands electric-operator-mode
  :init
  (add-hook 'python-mode-hook #'electric-operator-mode)
  (add-hook 'inferior-python-mode-hook #'electric-operator-mode))

(load "~/emacs-secrets/secrets.el")

(use-package wgrep
  :commands (wgrep-setup wgrep-change-to-wgrep-mode)
  :config
  (setq wgrep-auto-save-buffer t))

(use-package parrot
  :general
  (my/normal-keys
    "[r" 'parrot-rotate-prev-word-at-point
    "]r" 'parrot-rotate-next-word-at-point)
  :config
  (parrot-mode))

(use-package keychain-environment
  :config
  (keychain-refresh-environment))

(use-package comint
  :ensure nil
  :config
  (setq comint-input-ring-size 1000))

 (use-package gruvbox-theme
   :config
   (load-theme 'gruvbox-light-soft t)
   )
 ;;;###autoload
 (defun my/toggle-next-theme (theme1 theme2)
   (if (-contains? custom-enabled-themes theme1)
	(progn
	  (disable-theme theme1)
	  (load-theme theme2 t))
     (progn
	(disable-theme theme2)
	(load-theme theme1 t))))
 ;;;###autoload
 (defun my/switch-theme ()
   (interactive)
   (my/toggle-next-theme 'gruvbox-dark-soft 'gruvbox-light-soft))

 (my/leader-keys
   "Tn" 'my/switch-theme)

(use-package eyebrowse
  :init
  (add-hook 'after-init-hook 'eyebrowse-mode)
  (add-to-list 'window-persistent-parameters '(quit-restore . writable))
  :general
  (:keymaps 'override
   :states '(normal visual motion)
   ;; "gt" 'eyebrowse-next-window-config
   ;; "gT" 'eyebrowse-prev-window-config
   "gc" 'eyebrowse-close-window-config
   ;; "gr" 'eyebrowse-create-window-config
   "gl" 'eyebrowse-last-window-config
   "g0" 'eyebrowse-switch-to-window-config-0
   "g1" 'eyebrowse-switch-to-window-config-1
   "g2" 'eyebrowse-switch-to-window-config-2
   "g3" 'eyebrowse-switch-to-window-config-3
   "g4" 'eyebrowse-switch-to-window-config-4
   "g5" 'eyebrowse-switch-to-window-config-5
   "g6" 'eyebrowse-switch-to-window-config-6
   "g7" 'eyebrowse-switch-to-window-config-7
   "g8" 'eyebrowse-switch-to-window-config-8
   "g9" 'eyebrowse-switch-to-window-config-9)
  (my/leader-keys
    "w." 'hydra-eyebrowse/body
    "ww" 'eyebrowse-switch-to-window-config
    "wr" 'eyebrowse-rename-window-config)
  :config
  (setq eyebrowse-mode-line-style 'current
	  eyebrowse-new-workspace t)
  (custom-set-faces '(eyebrowse-mode-line-active ((nil))))
  (eyebrowse-mode))

(defhydra hydra-eyebrowse (:hint nil)
  "
 Go to^^^^^^                         Actions^^
 [_0_.._9_]^^     nth/new workspace  [_d_] close current workspace
 [_C-0_.._C-9_]^^ nth/new workspace  [_R_] rename current workspace
 [_<tab>_]^^^^    last workspace     [_q_] quit
 [_c_/_C_]^^      create workspace
 [_l_]^^^^        layouts
 [_n_/_C-l_]^^    next workspace
 [_N_/_p_/_C-h_]  prev workspace
 [_w_]^^^^        workspace w/helm/ivy\n"
  ("0" eyebrowse-switch-to-window-config-0 :exit t)
  ("1" eyebrowse-switch-to-window-config-1 :exit t)
  ("2" eyebrowse-switch-to-window-config-2 :exit t)
  ("3" eyebrowse-switch-to-window-config-3 :exit t)
  ("4" eyebrowse-switch-to-window-config-4 :exit t)
  ("5" eyebrowse-switch-to-window-config-5 :exit t)
  ("6" eyebrowse-switch-to-window-config-6 :exit t)
  ("7" eyebrowse-switch-to-window-config-7 :exit t)
  ("8" eyebrowse-switch-to-window-config-8 :exit t)
  ("9" eyebrowse-switch-to-window-config-9 :exit t)
  ("C-0" eyebrowse-switch-to-window-config-0)
  ("C-1" eyebrowse-switch-to-window-config-1)
  ("C-2" eyebrowse-switch-to-window-config-2)
  ("C-3" eyebrowse-switch-to-window-config-3)
  ("C-4" eyebrowse-switch-to-window-config-4)
  ("C-5" eyebrowse-switch-to-window-config-5)
  ("C-6" eyebrowse-switch-to-window-config-6)
  ("C-7" eyebrowse-switch-to-window-config-7)
  ("C-8" eyebrowse-switch-to-window-config-8)
  ("C-9" eyebrowse-switch-to-window-config-9)
  ("<tab>" eyebrowse-last-window-config)
  ("<return>" nil :exit t)
  ("TAB" eyebrowse-last-window-config)
  ("RET" nil :exit t)
  ("c" eyebrowse-create-window-config :exit t)
  ("C" eyebrowse-create-window-config)
  ("C-h" eyebrowse-prev-window-config)
  ("C-l" eyebrowse-next-window-config)
  ("d" eyebrowse-close-window-config)
  ("l" hydra-persp/body :exit t)
  ("n" eyebrowse-next-window-config)
  ("N" eyebrowse-prev-window-config)
  ("p" eyebrowse-prev-window-config)
  ("R" spacemacs/workspaces-ts-rename :exit t)
  ("w" eyebrowse-switch-to-window-config :exit t)
  ("q" nil))

(use-package persp-mode
  :config
  (setq persp-reset-windows-on-nil-window-conf t
	  persp-set-last-persp-for-new-frames nil)
  (persp-mode))

(use-package spacemacs-persp-extra
  :ensure nil
  :load-path "~/.emacs.d/site-lisp/spacemacs-persp-extra/"
  :commands (spacemacs/update-eyebrowse-for-perspective
	       spacemacs/save-eyebrowse-for-perspective
	       spacemacs/load-eyebrowse-for-perspective
	       spacemacs/load-eyebrowse-for-perspective)
  :general
  (:keymaps 'override
   :states '(normal visual motion)
    "g M-0" 'spacemacs/persp-switch-to-0
    "g M-1" 'spacemacs/persp-switch-to-1
    "g M-2" 'spacemacs/persp-switch-to-2
    "g M-3" 'spacemacs/persp-switch-to-3
    "g M-4" 'spacemacs/persp-switch-to-4
    "g M-5" 'spacemacs/persp-switch-to-5
    "g M-6" 'spacemacs/persp-switch-to-6
    "g M-7" 'spacemacs/persp-switch-to-7
    "g M-8" 'spacemacs/persp-switch-to-8
    "g M-9" 'spacemacs/persp-switch-to-9
    "g M-l" 'spacemacs/jump-to-last-layout
    "g M-c" 'spacemacs/layouts-ts-close)
  (my/leader-keys
    "l" 'hydra-persp/body)
  :init
  (add-hook 'persp-before-switch-functions
	      #'spacemacs/update-eyebrowse-for-perspective)
  (add-hook 'eyebrowse-post-window-switch-hook
	      #'spacemacs/save-eyebrowse-for-perspective)
  (add-hook 'persp-activated-functions
	      #'spacemacs/load-eyebrowse-for-perspective)
  (add-hook 'persp-before-save-state-to-file-functions
	      #'spacemacs/update-eyebrowse-for-perspective)
  (add-hook 'persp-after-load-state-functions
	      #'spacemacs/load-eyebrowse-after-loading-layout)
  (setq dotspacemacs-auto-generate-layout-names t
	  dotspacemacs-default-layout-name 'none)
  :config
  (defadvice persp-activate (before spacemacs//save-toggle-layout activate)
    (setq spacemacs--last-selected-layout persp-last-persp-name))
  (add-hook 'persp-mode-hook 'spacemacs//layout-autosave)
  (add-hook 'persp-created-functions
	      #'spacemacs//add-project-buffers-to-persp)
  (advice-add 'persp-load-state-from-file :before 'spacemacs//layout-wait-for-modeline))
(defhydra hydra-persp (:hint nil)
  "
 Go to^^^^^^                                  Actions^^
 [_0_.._9_]^^     nth/new layout              [_a_]^^   add buffer
 [_C-0_.._C-9_]^^ nth/new layout              [_A_]^^   add all from layout
 [_<tab>_]^^^^    last layout                 [_d_]^^   close current layout
 [_b_]^^^^        buffer in layout            [_D_]^^   close other layout
 [_h_]^^^^        default layout              [_L_]^^   load layouts from file
 [_l_]^^^^        layout w/helm/ivy           [_r_]^^   remove current buffer
 [_n_/_C-l_]^^    next layout                 [_R_]^^   rename current layout
 [_N_/_p_/_C-h_]  prev layout                 [_s_/_S_] save all layouts/save by names
 [_o_]^^^^        custom layout               [_t_]^^   show a buffer without adding it to current layout
 [_w_]^^^^        workspaces transient state  [_x_]^^   kill current w/buffers
 ^^^^^^                                       [_X_]^^   kill other w/buffers
 ^^^^^^                                       [_<_/_>_] move layout left/right
 ^^^^^^                                       "
  ("1" spacemacs/persp-switch-to-1 :exit t)
  ("2" spacemacs/persp-switch-to-2 :exit t)
  ("3" spacemacs/persp-switch-to-3 :exit t)
  ("4" spacemacs/persp-switch-to-4 :exit t)
  ("5" spacemacs/persp-switch-to-5 :exit t)
  ("6" spacemacs/persp-switch-to-6 :exit t)
  ("7" spacemacs/persp-switch-to-7 :exit t)
  ("8" spacemacs/persp-switch-to-8 :exit t)
  ("9" spacemacs/persp-switch-to-9 :exit t)
  ("0" spacemacs/persp-switch-to-0 :exit t)
  ("C-1" spacemacs/persp-switch-to-1)
  ("C-2" spacemacs/persp-switch-to-2)
  ("C-3" spacemacs/persp-switch-to-3)
  ("C-4" spacemacs/persp-switch-to-4)
  ("C-5" spacemacs/persp-switch-to-5)
  ("C-6" spacemacs/persp-switch-to-6)
  ("C-7" spacemacs/persp-switch-to-7)
  ("C-8" spacemacs/persp-switch-to-8)
  ("C-9" spacemacs/persp-switch-to-9)
  ("C-0" spacemacs/persp-switch-to-0)
  ("<tab>" spacemacs/jump-to-last-layout)
  ("<return>" nil :exit t)
  ("TAB" spacemacs/jump-to-last-layout)
  ("RET" nil :exit t)
  ("C-h" persp-prev)
  ("C-l" persp-next)
  ("<" spacemacs/move-current-persp-left)
  (">" spacemacs/move-current-persp-right)
  ("a" persp-add-buffer :exit t)
  ("A" persp-import-buffers :exit t)
  ("b" spacemacs/persp-buffers :exit t)
  ("d" spacemacs/layouts-ts-close)
  ("D" spacemacs/layouts-ts-close-other :exit t)
  ("h" spacemacs/layout-goto-default :exit t)
  ("L" persp-load-state-from-file :exit t)
  ("l" persp-switch :exit t)
  ("n" persp-next)
  ("N" persp-prev)
  ("o" spacemacs/select-custom-layout :exit t)
  ("p" persp-prev)
  ("r" persp-remove-buffer :exit t)
  ("R" spacemacs/layouts-ts-rename :exit t)
  ("s" persp-save-state-to-file :exit t)
  ("S" persp-save-to-file-by-names :exit t)
  ("t" persp-temporarily-display-buffer :exit t)
  ("w" hydra-eyebrowse/body :exit t)
  ("x" spacemacs/layouts-ts-kill)
  ("X" spacemacs/layouts-ts-kill-other :exit t)
  ("q" nil))

(use-package projectile
  :diminish projectile-mode
  :commands (projectile-ack
	       projectile-ag
	       projectile-compile-project
	       projectile-dired
	       projectile-find-dir
	       projectile-find-file
	       projectile-find-tag
	       projectile-test-project
	       projectile-grep
	       projectile-invalidate-cache
	       projectile-kill-buffers
	       projectile-multi-occur
	       projectile-project-p
	       projectile-project-root
	       projectile-recentf
	       projectile-regenerate-tags
	       projectile-replace
	       projectile-replace-regexp
	       projectile-run-async-shell-command-in-root
	       projectile-run-shell-command-in-root
	       projectile-switch-project
	       projectile-switch-to-buffer
	       projectile-vc)
  ;; :general
  ;; (my/leader-keys
  ;;   ;; Project
  ;;   "p!" 'projectile-run-shell-command-in-root
  ;;   "p&" 'projectile-run-async-shell-command-in-root
  ;;   "p%" 'projectile-replace-regexp
  ;;   "pa" 'projectile-toggle-between-implementation-and-test
  ;;   "pb" 'projectile-switch-to-buffer
  ;;   "pc" 'projectile-compile-project
  ;;   "pd" 'projectile-find-dir
  ;;   "pD" 'projectile-dired
  ;;   "pe" 'projectile-edit-dir-locals
  ;;   "pf" 'projectile-find-file
  ;;   "pF" 'projectile-find-file-dwim
  ;;   "pg" 'projectile-find-tag
  ;;   "pG" 'projectile-regenerate-tags
  ;;   "pI" 'projectile-invalidate-cache
  ;;   "pk" 'projectile-kill-buffers
  ;;   "po" 'projectile-find-other-file
  ;;   "pp" 'projectile-switch-project
  ;;   "pr" 'projectile-recentf
  ;;   "pR" 'projectile-replace
  ;;   "pT" 'projectile-test-project
  ;;   "pv" 'projectile-vc)
  :config
  (progn
    (setq projectile-indexing-method 'hybrid)
    (add-to-list 'projectile-other-file-alist '("tex" . ("pdf")))
    (add-to-list 'projectile-other-file-alist '("pdf" . ("tex")))
    (setq projectile-project-root-files-functions
    '(projectile-root-top-down projectile-root-local
    projectile-root-bottom-up
    projectile-root-top-down-recurring))
    (setq projectile-project-root-files #'(".projectile"))
    (projectile-mode)))

 (use-package avy
   :config
   (setq avy-all-windows nil
	  avy-background t
	  avy-flyspell-correct-function #'flyspell-correct-at-point)
   :general
   (:keymaps 'override
	      [remap evil-find-char] 'my/avy-goto-char-in-line-without-background)
   (my/leader-keys
     "jj" 'avy-goto-char-timer
     "j M-j" 'my/avy-goto-char-timer-all-windows
     "jl" 'avy-goto-line
     "j M-l" 'my/avy-goto-line-all-windows
     "jw" 'avy-goto-word-or-subword-1
     "j M-w" 'my/avy-goto-word-or-subword-1-all-windows
     "jc" 'avy-goto-char
     "j M-c" 'my/avy-goto-char-all-windows)
   (my/leader-keys-major-mode
     :keymaps 'org-mode-map
     "jj" 'avy-org-goto-heading-timer)
   (my/all-states-keys
     "M-e" 'avy-goto-word-1
     "M-r" 'avy-goto-char
     "C-'" 'avy-goto-line))

   ;;;###autoload
   (defun my/avy-goto-char-timer-all-windows ()
     (interactive)
     (let ((avy-all-windows t))
	(avy-goto-char-autoload)))

   ;;;###timer
   (defun my/avy-goto-line-all-windows ()
     (interactive)
     (let ((avy-all-windows t))
	(avy-goto-line)))

   ;;;###autoload
   (defun my/avy-goto-word-or-subword-1-all-windows ()
     (interactive)
     (let ((avy-all-windows t))
	(avy-goto-word-or-subword-1)))

   ;;;###autoload
   (defun my/avy-goto-char-all-windows ()
     (interactive)
     (let ((avy-all-windows t))
	(call-interactively 'avy-goto-char)))

   ;;;###autoload
   (defun my/avy-goto-char-in-line-without-background ()
     (interactive)
     (let ((avy-background nil))
	(call-interactively 'avy-goto-char-in-line)))

(use-package winum
  :ghook ('after-init-hook)
  :general
  (:states '(insert normal visual motion)
	     :keymaps 'override
	     "M-1" 'winum-select-window-1
	     "M-2" 'winum-select-window-2
	     "M-3" 'winum-select-window-3
	     "M-4" 'winum-select-window-4
	     "M-5" 'winum-select-window-5
	     "M-6" 'winum-select-window-6
	     "M-7" 'winum-select-window-7
	     "M-8" 'winum-select-window-8
	     "M-9" 'winum-select-window-9)
  :config
  (setq winum-auto-assign-0-to-minibuffer nil
	  winum-mode-line-position 1
	  winum-ignored-buffers '(" *which-key*" "*helm M-x*" "*helm find files*" "*helm mini*" "*Helm Swoop*")
	  winum-scope 'frame-local
	  winum-reverse-frame-list t)
  (winum-mode))

(use-package golden-ratio-scroll-screen
  :general
  (:states '(normal visual motion)
   :keymaps 'override
	     "C-f" 'golden-ratio-scroll-screen-up
	     "C-b" 'golden-ratio-scroll-screen-down))

 (use-package ace-link
   :commands (ace-link-info
	       ace-link-help
	       ace-link-eww)
   :init
   (progn
     (with-eval-after-load 'info
	(define-key Info-mode-map "o" 'ace-link-info))
     (with-eval-after-load 'help-mode
	(define-key help-mode-map "o" 'ace-link-help))
     (with-eval-after-load 'eww
	(define-key eww-link-keymap "o" 'ace-link-eww)
	(define-key eww-mode-map "o" 'ace-link-eww))))

(use-package ace-window
  :general
  (my/leader-keys
    "wM" 'ace-swap-window
    "wW" 'ace-window))

(use-package dumb-jump
  :general
  (my/all-states-keys
    :states '(insert emacs normal)
    "M-g o" 'dumb-jump-go-other-window
    "M-g g" 'dumb-jump-go
    "M-g l" 'dumb-jump-quick-look
    "M-g x" 'dumb-jump-go-prefer-external
    "M-g z" 'dumb-jump-go-prefer-external-other-window)
  :config
  (progn
    (setq dumb-jump-selector 'ivy)))

 (use-package helm
   :commands helm-mode
   :init
   (progn
     (with-eval-after-load 'helm
	(global-set-key (kbd "M-x") #'helm-M-x)
	(define-key helm-map (kbd "C-j") 'helm-next-line)
	(define-key helm-map (kbd "C-k") 'helm-previous-line)
	(define-key helm-map (kbd "C-S-j") 'helm-follow-action-forward)
	(define-key helm-map (kbd "C-S-k") 'helm-follow-action-backward)
	(define-key helm-map (kbd "C-h") 'helm-next-source)
	(define-key helm-map (kbd "C-S-h") 'describe-key)
	(define-key helm-map (kbd "C-l") (kbd "RET")))
     (with-eval-after-load 'helm-files
	(dolist (keymap (list helm-find-files-map helm-read-file-map))
	  (define-key keymap (kbd "C-l") 'helm-execute-persistent-action)
	  (define-key keymap (kbd "C-h") 'helm-find-files-up-one-level)
	  ;; rebind `describe-key' for convenience
	  (define-key keymap (kbd "C-S-h") 'describe-key)))
     (my/leader-keys
	"a'" 'helm-available-repls
	"bb" 'helm-mini
	"Cl"   'helm-colors
	"fb" 'helm-filtered-bookmarks
	"ff"   'helm-find-files
	"fl"   'helm-locate
	"fr"   'helm-recentf
	"hda"  'helm-apropos
	"hdF"  'my/helm-faces
	"hdb" 'describe-bindings
	"hdc" 'describe-char
	"hdf" 'describe-function
	"hdk" 'describe-key
	"hdp" 'describe-package
	"hdt" 'describe-theme
	"hdv" 'describe-variable
	"hn"  'view-emacs-news
	"hPs" 'profiler-start
	"hPk" 'profiler-stop
	"hPr" 'profiler-report
	"hPw" 'profiler-report-write-profile
	"hi"   'helm-info-at-point
	"hm"   'helm-man-woman
	"iu"   'helm-ucs
	"ji" 'helm-imenu
	"jI"   'helm-imenu-in-all-buffers
	"rm"   'helm-all-mark-rings
	"rl"   'helm-resume
	"rr"   'helm-register
	"ry"   'helm-show-kill-ring
	)
     (my/leader-keys-major-mode
	:keymaps 'org-mode-map
	"jh" 'helm-org-in-buffer-headings)
     (my/all-states-keys
	:keymaps 'inferior-python-mode-map
	"M-h" 'helm-comint-input-ring)
     :config
     (progn
	(custom-set-faces '(helm-action ((t (:foreground "dark sea green" :underline nil)))) )
	(setq helm-split-window-inside-p t
	      helm-echo-input-in-header-line t
	      helm-autoresize-min-height 20
	      helm-autoresize-max-height 0
	      helm-mode-fuzzy-match t
	      helm-completion-in-region-fuzzy-match t)
	(defun spacemacs//helm-hide-minibuffer-maybe ()
	  "Hide minibuffer in Helm session if we use the header line as input field."
	  (when (with-helm-buffer helm-echo-input-in-header-line)
	    (let ((ov (make-overlay (point-min) (point-max) nil nil t)))
	      (overlay-put ov 'window (selected-window))
	      (overlay-put ov 'face
			   (let ((bg-color (face-background 'default nil)))
			     `(:background ,bg-color :foreground ,bg-color)))
	      (setq-local cursor-type nil))))
	(add-hook 'helm-minibuffer-set-up-hook
		  'spacemacs//helm-hide-minibuffer-maybe)
	(helm-mode)
	(helm-autoresize-mode))))

(use-package helm-describe-modes
  :after helm
  :init
  (global-set-key [remap describe-mode] #'helm-describe-modes))

 (use-package helm-projectile
   :commands (helm-projectile-switch-to-buffer
	       helm-projectile-find-dir
	       helm-projectile-dired-find-dir
	       helm-projectile-recentf
	       helm-projectile-find-file
	       helm-projectile-grep
	       helm-projectile
	       helm-projectile-switch-project)
   :init
   (progn
     (my/leader-keys
	"pb"  'helm-projectile-switch-to-buffer
	"pd"  'helm-projectile-find-dir
	"pf"  'helm-projectile-find-file
	"pF"  'helm-projectile-find-file-dwim
	"ph"  'helm-projectile
	"pp"  'helm-projectile-switch-project
	"pr"  'helm-projectile-recentf
	"sgp" 'helm-projectile-grep)))

 (use-package helm-ag
   :commands (helm-do-ag
	       helm-do-ag-buffers
	       helm-do-ag-thi-file
	       helm-do-ag-project-root)
   :init
   (progn
     (my/leader-keys
	"sa" 'helm-do-ag
	"sb" 'helm-do-ag-buffers
	"s M-b" 'helm-do-ag-this-file
	"sp" 'helm-do-ag-project-root)))

 (use-package helm-swoop
   :commands helm-swoop
   :init
   (progn
     (my/leader-keys
	"ss" 'helm-swoop))
   :config
   (progn
     (setq helm-swoop-split-with-multiple-windows t
	    helm-swoop-speed-or-color t
	    helm-swoop-pre-input-function (lambda () "")
	    helm-swoop-move-to-line-cycle nil)
     (custom-set-faces '(helm-swoop-target-word-face ((t (:inherit lazy-highlight)))))))

(use-package helm-themes
  :general
  (my/leader-keys
    "Ts" 'helm-themes))

(use-package helm-xref
  :commands (helm-xref-show-xrefs)
  :init
  (progn
    ;; This is required to make `xref-find-references' not give a prompt.
    ;; `xref-find-references' asks the identifier (which has no text property)
    ;; and then passes it to `lsp-mode', which requires the text property at
    ;; point to locate the references.
    ;; https://debbugs.gnu.org/cgi/bugreport.cgi?bug=29619
    (setq xref-prompt-for-identifier '(not xref-find-definitions
					     xref-find-definitions-other-window
					     xref-find-definitions-other-frame
					     xref-find-references
					     spacemacs/jump-to-definition))
    ;; Use helm-xref to display `xref.el' results.
    (setq xref-show-xrefs-function #'helm-xref-show-xrefs)))

 (use-package helm-descbinds
   :init
   (progn
     (setq helm-descbinds-window-style 'split)
     (add-hook 'helm-mode-hook 'helm-descbinds-mode)
     (my/leader-keys
	"?" 'helm-descbinds)))

(use-package helm-flx
  :after helm
  :config
  (helm-flx-mode))

(use-package flyspell-correct-helm
  :commands (flyspell-correct-helm)
  :general
  (:keymaps 'override
	      "C-;" 'flyspell-correct-wrapper)
  :init
  (setq flyspell-correct-interface #'flyspell-correct-helm))

 (use-package helm-org-rifle
   :commands (helm-org-rifle-agenda-files
	       helm-org-rifle-occur-agenda-files)
   :init
   (progn
     (my/leader-keys-major-mode
	:keymaps 'org-mode-map
	"s M-r" 'helm-org-rifle-agenda-files
	"so" 'helm-org-rifle-occur-agenda-files)
     (my/leader-keys
	"aor" 'helm-org-rifle-agenda-files)))

 (use-package helm-bibtex
   :commands helm-bibtex
   :init
   (progn
     (my/leader-keys
	"ib" 'ivy-bibtex)
     ;; (my/leader-keys-minor-mode
     ;;   :keymaps 'bibtex-completion-notes-mode-map
     ;;   "s" 'bibtex-completion-exit-notes-buffer)
     )
   :general
   (ivy-minibuffer-map
    "C-j" 'ivy-next-line
    "C-k" 'ivy-previous-line
    "C-h" (kbd "DEL")
    "C-l" 'ivy-alt-done)
   :config
   (setq bibtex-completion-pdf-field "file"
	  bibtex-completion-find-additional-pdfs t
	  bibtex-completion-bibliography "~/Dropbox/software/Zotero/bibtex/main.bib"
	  bibtex-completion-notes-path "~/Dropbox/document/org/references/ref-notes.org"
	  bibtex-completion-notes-template-one-file
	  "\n** ${title}\n  :PROPERTIES:\n  :Custom_ID: ${=key=}\n  :NOTER_DOCUMENT: ${file}\n  :END:\n\n"
	  bibtex-completion-additional-search-fields '(eventtitle)
	  bibtex-completion-display-formats
	  '((article       . "${=has-pdf=:1}${=has-note=:1} ${=type=:3} ${year:4} ${author:36} ${title:*} ${journal:40}")
	    (inbook        . "${=has-pdf=:1}${=has-note=:1} ${=type=:3} ${year:4} ${author:36} ${title:*} Chapter ${chapter:32}")
	    (incollection  . "${=has-pdf=:1}${=has-note=:1} ${=type=:3} ${year:4} ${author:36} ${title:*} ${booktitle:40}")
	    (inproceedings . "${=has-pdf=:1}${=has-note=:1} ${=type=:3} ${year:4} ${author:36} ${title:*} ${eventtitle:40}")
	    (t             . "${=has-pdf=:1}${=has-note=:1} ${=type=:3} ${year:4} ${author:36} ${title:*} ${eventtitle:40}"))))

(use-package helm-pydoc
  :commands helm-pydoc
  :init
  (my/leader-keys-major-mode
    :keymaps 'python-mode-map
    "hd" 'helm-pydoc))

;;;###autoload
;; copy from spacemacs
(defun my/helm-faces ()
  "Describe face."
  (interactive)
  (require 'helm-elisp)
  (let ((default (or (face-at-point) (thing-at-point 'symbol))))
    (helm :sources (helm-def-source--emacs-faces
		      (format "%s" (or default "default")))
	    :buffer "*helm faces*")))

(use-package helm-posframe
  :if (and (window-system) (version<= "26.1" emacs-version))
  :init
  (add-hook 'helm-org-rifle-after-command-hook 'helm-posframe-cleanup)
  :config
  (setq helm-posframe-poshandler 'posframe-poshandler-frame-center
	  helm-posframe-height 10
	  helm-posframe-width (round (* (frame-width) 0.49))
	  helm-posframe-parameters '((internal-border-width . 10)))
  (helm-posframe-enable))

(use-package ivy
  :diminish ivy-mode
  :general
  (my/leader-keys
    "bb" 'ivy-switch-buffer)
  (my/non-insert-keys
    "M-b" 'ivy-switch-buffer)
  (:keymaps 'ivy-minibuffer-map
   "C-j" 'ivy-next-line
   "C-k" 'ivy-previous-line
   "C-h" (kbd "DEL")
   "C-l" 'ivy-alt-done)
  (:keymaps 'ivy-switch-buffer-map
   "C-k" 'ivy-previous-line
   "M-k" 'ivy-switch-buffer-kill)
  :config
  (setq ivy-use-virtual-buffers t
	  ivy-re-builders-alist '((t . ivy--regex-ignore-order))
	  ivy-initial-inputs-alist nil
	  ivy-count-format "(%d/%d) ")
  (ivy-mode))

(use-package ivy-avy
  :init
  (setq ivy-avy-style 'at-full))

(use-package ivy-prescient
  :after (ivy counsel)
  :config
  (ivy-prescient-mode)
  (prescient-persist-mode))

(use-package ivy-rich
  :after (ivy counsel)
  :config
  (ivy-rich-mode 1))

(use-package ivy-hydra)

(use-package counsel
  :after (ivy swiper)
  :general
  ("M-x" 'counsel-M-x)
  (my/non-insert-keys
    "M-f" 'counsel-find-file)
  (my/leader-keys
    ;; files
    "fb" 'counsel-bookmark
    "ff" 'counsel-find-file
    "fl" 'counsel-locate
    "fr" 'counsel-recoll
    ;; help
    "?"   'counsel-descbinds
    "hda" 'counsel-apropos
    "hdf" 'counsel-describe-function
    "hdF" 'counsel-describe-face
    "hdv" 'counsel-describe-variable
    "hi"  'counsel-info-lookup-symbol
    "ji" 'counsel-imenu
    ;; register/ring
    "ry"  'counsel-yank-pop
    "rm"  'counsel-mark-ring
    ;; search
    "sa" 'counsel-ag
    "sp" 'counsel-projectile-ag
    ;; themes
    "Ts"  'counsel-load-theme
    ;; insert color
    "ic" 'counsel-colors-emacs
    "iu" 'counsel-unicode-char)
  (my/all-states-keys
    "M-y" 'counsel-yank-pop)
  (my/all-states-keys
    :keymaps 'inferior-python-mode-map
    "M-h" 'counsel-shell-history)
  :config
  (setq counsel-yank-pop-preselect-last t
	  counsel-ag-base-command "ag --vimgrep --skip-vcs-ignores %s")
  (add-to-list 'ivy-height-alist `(counsel-yank-pop . ,ivy-height))
  (counsel-mode))

(use-package swiper
  :general
  ("C-s" 'swiper)
  (my/leader-keys
   "ss" 'swiper))

(use-package ivy-xref
  :after (ivy xref)
  :init
  (when (>= emacs-major-version 27)
    (setq xref-show-definitions-function #'ivy-xref-show-defs))
  ;; Necessary in Emacs <27. In Emacs 27 it will affect all xref-based
  ;; commands other than xref-find-definitions (e.g. project-find-regexp)
  ;; as well
  (setq xref-show-xrefs-function #'ivy-xref-show-xrefs
	  ivy-xref-remove-text-properties t))

(use-package amx
  :commands (counsel-M-X)
  :config
  (amx-mode))

 (use-package ivy-bibtex
   :commands ivy-bibtex
   :init
   (progn
     (my/leader-keys
	"ib" 'ivy-bibtex)
     ;; (my/leader-keys-minor-mode
     ;;   :keymaps 'bibtex-completion-notes-mode-map
     ;;   "s" 'bibtex-completion-exit-notes-buffer)
     )
   :config
   (setq bibtex-completion-pdf-field "file"
	  bibtex-completion-cite-prompt-for-optional-arguments nil
	  bibtex-completion-pdf-symbol "ρ"
	  bibtex-completion-notes-symbol "η"
	  bibtex-completion-find-additional-pdfs t
	  bibtex-completion-bibliography "~/Dropbox/software/Zotero/bibtex/main.bib"
	  bibtex-completion-notes-path "~/Dropbox/document/org/references/ref-notes.org"
	  bibtex-completion-notes-template-one-file
	  "\n** ${title}\n  :PROPERTIES:\n  :Custom_ID: ${=key=}\n  :NOTER_DOCUMENT: ${file}\n  :END:"
	  bibtex-completion-additional-search-fields '(eventtitle)
	  bibtex-completion-display-formats
	  '((t . "${=has-pdf=:1} ${=has-note=:1} ${=type=:3} ${year:4} ${author:25} ${title:100}"))))

(use-package counsel-projectile
  :general
  (my/leader-keys
    "p SPC" 'counsel-projectile
    "pf" 'counsel-projectile-find-file
    "pb" 'counsel-projectile-switch-to-buffer
    "pd" 'counsel-projectile-find-dir
    "pp" 'counsel-projectile-switch-project
    "psg" 'counsel-projectile-grep
    "pss" 'counsel-projectile-ag
    "psr" 'counsel-projectile-rg)
  :config
  (counsel-projectile-mode))

(use-package flyspell-correct-ivy
  :general
  (my/all-states-keys
    "C-;" 'flyspell-correct-wrapper)
  :init
  (setq flyspell-correct-interface #'flyspell-correct-ivy))

(use-package ivy-posframe
  :if (and (window-system) (version<= "26.1" emacs-version))
  :after ivy
  :config
  (setq ivy-posframe-hide-minibuffer t
	  ivy-posframe-border-width 2
	  ivy-posframe-min-width 80
	  ivy-posframe-min-height 10
	  ivy-posframe-width nil
	  ivy-posframe-height nil)
  (setq ivy-posframe-display-functions-alist
	  '((swiper . ivy-posframe-display-at-window-bottom-left)
	    (t . ivy-posframe-display-at-frame-center)
	    ))
  (ivy-posframe-mode 1))

(use-package counsel-dash
  :general
  (my/leader-keys
    "d" '(:ignore t :wk "documents")
    "dh" 'counsel-dash)
  :config
  (setq counsel-dash-browser-func 'eww))

 (use-package company
   :diminish company-mode
   :init
   (progn
     (add-hook 'after-init-hook 'global-company-mode))
   :config
   ;; (add-hook 'evil-normal-state-entry-hook
   ;; 	    (lambda ()
   ;; 	      (when (or (company-tooltip-visible-p) (my/company-posframe-visible-p company-posframe-buffer))
   ;; 		(company-cancel))))
   (progn
     (let ((map company-active-map))
	(define-key map (kbd "C-j") 'company-select-next)
	(define-key map (kbd "C-k") 'company-select-previous)
	(define-key map (kbd "C-l") 'company-complete-selection))
     (setq company-idle-delay 0.0
	    company-show-numbers t
	    company-tooltip-idle-delay 0.0
	    company-echo-delay 0.0
	    company-minimum-prefix-length 1
	    company-tooltip-align-annotations t
	    company-dabbrev-ignore-case nil
	    company-dabbrev-downcase nil
	    company-ispell-dictionary (file-truename "~/.emacs.d/dict/words_alpha.txt")
	    ispell-alternate-dictionary (file-truename "~/.emacs.d/dict/words_alpha.txt")
	    company-transformers '(company-sort-by-backend-importance)
	    company-dabbrev-code-other-buffers 'code
	    company-dabbrev-ignore-case nil
	    company-dabbrev-downcase nil
	    company-dabbrev-code-time-limit 5
	    company-dabbrev-code-modes '(python-mode inferior-python-mode)
	    company-backends '(company-capf
			       company-dabbrev-code
			       company-keywords
			       company-files
			       company-ispell
			       company-yasnippet
			       company-abbrev))
     (push (apply-partially #'cl-remove-if
			     (lambda (c)
			       (or (string-match-p "[^\x00-\x7F]+" c)
				   (string-match-p "[0-9]+" c)
				   (string-match-p "__.*__" c)
				   )))
	    company-transformers)
     (defun ora-company-number ()
	"Forward to `company-complete-number'. Unless the number is
 potentially part of the candidate. In that case, insert the
 number."
	(interactive)
	(let* ((k (this-command-keys))
	       (re (concat "^" company-prefix k)))
	  (if (or (cl-find-if (lambda (s) (string-match re s))
			      company-candidates)
		  (> (string-to-number k)
		     (length company-candidates))
		  (looking-back "[0-9]+\\.[0-9]*" (line-beginning-position)))
	      (self-insert-command 1)
	    (company-complete-number
	     (if (equal k "0")
		 10
	       (string-to-number k))))))

     (defun ora--company-good-prefix-p (orig-fn prefix)
	(unless (and (stringp prefix) (string-match-p "\\`[0-9]+\\'" prefix))
	  (funcall orig-fn prefix)))

     (advice-add 'company--good-prefix-p :around #'ora--company-good-prefix-p)

     (defun my-space ()
	(interactive)
	(company-abort)
	(self-insert-command 1))

     (let ((map company-active-map))
	(mapc (lambda (x) (define-key map (format "%d" x) 'ora-company-number))
	      (number-sequence 0 9))
	(define-key map " " 'my-space)
	(define-key map (kbd "<return>") nil))))

(use-package company-statistics
  :after company
  :config
  (company-statistics-mode))

(use-package company-prescient
  :after company
  :config
  (company-prescient-mode))

(use-package yasnippet
  :ghook ('(prog-mode-hook
	      org-mode-hook
	      LaTeX-mode-hook)
	    #'yas-minor-mode))

(use-package yasnippet-snippets
  :after yasnippet)

(use-package ivy-yasnippet
  :commands ivy-yasnippet
  :init
  (progn
    (setq ivy-yasnippet-expand-keys nil)
    (my/leader-keys
     "is" 'ivy-yasnippet)))

(use-package auto-yasnippet
  :general
  (my/leader-keys
    "iSc" 'aya-create
    "iSe" 'aya-expand
    "iSw" 'aya-persist-snippet)
  :config
  (setq aya-trim-one-line t))