Emacs Configuration

(defvar nasy/config-before-hook nil
  "Hooks to run config functions before load custom.el.")

(defvar nasy/config-after-hook nil
  "Hooks to run config functions after.")

(add-hook 'nasy/config-after-hook
          #'(lambda () (message "Hi~ Hope you have fun with this config.")))

(add-hook 'after-init-hook
          #'(lambda () (run-hooks 'nasy/config-after-hook)))

(defgroup nasy nil
  "Nasy Emacs Custom Configurations."
  :group 'emacs)

(defcustom lisp-modes-hooks '(cider-repl-mode-hook
                              clojure-mode-hook
                              clojurec-mode-hook
                              clojurescript-mode-hook
                              clojurex-mode-hook
                              common-lisp-mode-hook
                              emacs-lisp-mode-hook
                              eshell-mode-hook
                              geiser-repl-mode-hook
                              gerbil-mode-hook
                              inf-clojure-mode-hook
                              inferior-emacs-lisp-mode-hook
                              inferior-lisp-mode-hook
                              inferior-scheme-mode-hook
                              lisp-interaction-mode-hook
                              lisp-mode-hook
                              monroe-mode-hook
                              racket-mode-hook
                              racket-repl-mode-hook
                              scheme-interaction-mode-hook
                              scheme-mode-hook
                              slime-repl-mode-hook
                              stumpwm-mode-hook)
  "List of lisp-related modes hooks."
  :type '(repeat symbol)
  :group 'nasy)

(defcustom *clangd* (executable-find "clangd")
  "Clangd path.  If nil, will not use clangd."
  :group 'nasy
  :type 'string)

(defcustom *ccls* (executable-find "ccls")  ;; macOS
  "Ccls path.  If nil, will not use ccls."
  :group 'nasy
  :type 'string)

(defcustom *eldoc-box* nil
  "Whether to use eloc-box or not."
  :group 'nasy
  :type 'boolean)

(defcustom *nix* nil
  "Nix path.  If nil, will not use nix."
  :group 'nasy
  :type 'string)

(defcustom *rust* (or (executable-find "rustc")
                      (executable-find "cargo")
                      (executable-find "rustup"))
  "The Rust path.  If nil, will not use Rust."
  :group 'nasy
  :type 'string)

(defcustom *rls* (executable-find "rls")
  "The rls path.  If nil, will not use rls."
  :group 'nasy
  :type 'string)

(defcustom *debug* t
  "Whether to use debug or not."
  :group 'nasy
  :type 'boolean)

(defcustom *server* t
  "Whether to use server or not."
  :group 'nasy
  :type 'boolean)

(defcustom *intero* t
  "Whether to use intero or not."
  :group 'nasy
  :type 'boolean)

(defcustom *struct-hs* (executable-find "structured-haskell-mode")
  "The structured-haskell-mode path.  If nil, will not use structured-haskell-mode."
  :group 'nasy
  :type 'string)

(defcustom *blacken* nil
  "Whether to use blacken or not."
  :group 'nasy
  :type 'boolean)

(defcustom *c-box* t
  "Whether to use company box or not."
  :group 'nasy
  :type 'boolean)

(defcustom *ivy-posframe* nil
  "Whether to use ivy-posframe or not."
  :group 'nasy
  :type 'boolean)

(defcustom *vterm* nil
  "Whether to use vterm or not."
  :group 'nasy
  :type 'boolean)

(defcustom *org-headline-rescale* t
  "Whether to rescale org-headline or not."
  :group 'nasy
  :type 'boolean)

(defcustom *ispell* (executable-find "aspell")
  "The Ispell.  If nil, will not use Ispell."
  :group 'nasy
  :type 'string)

(defcustom *theme* 'doom-dracula
  "The Theme."
  :group 'nasy
  :type 'symbol)

(defcustom *dvorak* nil
  "Whether to use dvorak or not."
  :group 'nasy
  :type 'boolean)

(defcustom *mouse-color* "black"
  "Mouse color."
  :group 'nasy
  :type 'string)

(defcustom *font* "OperatorMonoSSmLig Nerd Font"
 "The main font.  After change it, run `M-x nasy/set-font' to see the effect."
 :group 'nasy
 :type 'string)

(defcustom *font-size* 12.0
 "The main font.  After change it, run `M-x nasy/set-font' to see the effect."
 :group 'nasy
 :type 'float)

(defcustom *font-weight* 'normal
 "The main font.  After change it, run `M-x nasy/set-font' to see the effect."
 :group 'nasy
 :type 'symbol)

(defcustom *font-cjk* "Xingkai SC"
 "The cjk font.  After change it, run `M-x nasy/set-font' to see the effect."
 :group 'nasy
 :type 'string)

(defcustom *font-size-cjk* 16.0
 "The cjk font.  After change it, run `M-x nasy/set-font' to see the effect."
 :group 'nasy
 :type 'float)

(defcustom *font-weight-cjk* 'light
 "The cjk font.  After change it, run `M-x nasy/set-font' to see the effect."
 :group 'nasy
 :type 'symbol)

(straight-use-package 'general)
(use-package general
  :init
  (defalias 'gsetq #'general-setq)
  (defalias 'gsetq-local #'general-setq-local)
  (defalias 'gsetq-default #'general-setq-default))

(when *is-a-mac*
  (gsetq mac-option-modifier  'meta
         mac-command-modifier 'hyper
         mac-right-command-modifier 'control)

  (general-define-key
   "C-z" 'stop-minimizing-window

   ;; cursor Movement
   "H-<up>"   'beginning-of-buffer
   "H-<down>" 'end-of-buffer
   "H-l"      'goto-line

   ;; text Operations
   "H-a" 'mark-whole-buffer
   "H-v" 'yank
   "H-c" 'kill-ring-save
   "H-s" 'save-buffer
   "H-z" 'undo
   "H-w" (lambda! (delete-window))
   "M-¥" (lambda! (insert "\\"))
   "H-<backspace>" (lambda! (kill-line 0)))

  ;; unset
  (global-unset-key (kbd "<magnify-down>"))
  (global-unset-key (kbd "<magnify-up>")))

(add-hook #'nasy/config-after-hook
          #'(lambda ()
              (when *dvorak*
                (general-define-key
                 :keymaps 'key-translation-map
                 "C-," "C-x"
                 "C-x" "C-,"
                 "M-," "M-x"
                 "M-x" "M-,"
                 "C-c" "C-."
                 "C-." "C-c"
                 "M-c" "M-."
                 "M-." "M-c"))))

(general-define-key
 "<mouse-4>" (lambda! (scroll-down 1))
 "<mouse-5>" (lambda! (scroll-up 1)))

(when *is-a-mac*
  (add-to-list 'default-frame-alist
               '(ns-transparent-titlebar . t))

  (add-to-list 'default-frame-alist
               '(ns-appearance . dark))

  (add-to-list 'default-frame-alist
               '(alpha . (80 . 75)))

  (defun stop-minimizing-window ()
    "Stop minimizing window under macOS."
    (interactive)
    (unless (and *is-a-mac*
                 window-system)
      (suspend-frame))))

(setq use-file-dialog        nil
      use-dialog-box         nil
      inhibit-startup-screen t)

(when (fboundp 'tool-bar-mode)
  (tool-bar-mode -1))

(when (fboundp 'set-scroll-bar-mode)
  (set-scroll-bar-mode nil))

;; https://github.com/jwiegley/emacs-async
(straight-use-package 'async)
(use-package dired-async
  :commands dired-async-mode)
(use-package async-bytecomp
  :config
  (gsetq async-bytecomp-allowed-packages '(all))
  (async-bytecomp-package-mode))

;; (straight-use-package 'auto-compile)
;; (require 'auto-compile)
;; (auto-compile-on-load-mode)
;; (auto-compile-on-save-mode)

(setq-default compilation-scroll-output t)

;; https://github.com/jwiegley/alert
(straight-use-package 'alert)
(use-package alert
  :defer    t
  :preface
  (defun alert-after-compilation-finish (buf result)
    "Use `alert' to report compilation RESULT if BUF is hidden."
    (when (buffer-live-p buf)
      (unless (catch 'is-visible
                (walk-windows (lambda (w)
                                (when (eq (window-buffer w) buf)
                                  (throw 'is-visible t))))
                nil)
        (alert (concat "Compilation " result)
               :buffer buf
               :category 'compilation)))))


(use-package compile
  :defer t
  :preface
  (defvar nasy/last-compilation-buffer nil
    "The last buffer in which compilation took place.")

  (defun nasy/save-compilation-buffer (&rest _)
    "Save the compilation buffer to find it later."
    (setq nasy/last-compilation-buffer next-error-last-buffer))
  (advice-add 'compilation-start :after 'nasy/save-compilation-buffer)

  (defun nasy/find-prev-compilation (orig &rest args)
    "Find the previous compilation buffer, if present, and recompile there."
    (if (and (null edit-command)
             (not (derived-mode-p 'compilation-mode))
             nasy:last-compilation-buffer
             (buffer-live-p (get-buffer nasy/last-compilation-buffer)))
        (with-current-buffer nasy/last-compilation-buffer
          (apply orig args))
      (apply orig args)))
  :bind (([f6] . recompile))
  :hook ((compilation-finish-functions . alert-after-compilation-finish)))

(use-package ansi-color
  :defer    t
  :preface
  (defun colourise-compilation-buffer ()
    (when (eq major-mode 'compilation-mode)
      (ansi-cOLOR-APPLY-on-region compilation-filter-start (point-max))))
  :hook ((compilation-filter . colourise-compilation-buffer)))

(require 'jka-compr)
(auto-compression-mode)

(gsetq desktop-path              (list user-emacs-directory no-littering-var-directory)
       desktop-dirname           (list user-emacs-directory no-littering-var-directory)
       desktop-auto-save-timeout 600)
(desktop-save-mode t)
(gsetq desktop-save 'if-exists)


(defun nasy/desktop-time-restore (orig &rest args)
  (let ((start-time (current-time)))
    (prog1
        (apply orig args)
      (message "Desktop restored in %.2fms"
               (benchmark-init/time-subtract-millis (current-time)
                                               start-time)))))
(advice-add 'desktop-read :around 'nasy/desktop-time-restore)

(defun nasy/desktop-time-buffer-create (orig ver filename &rest args)
  (let ((start-time (current-time)))
    (prog1
        (apply orig ver filename args)
      (message "Desktop: %.2fms to restore %s"
               (benchmark-init/time-subtract-millis (current-time)
                                               start-time)
               (when filename
                 (abbreviate-file-name filename))))))
(advice-add 'desktop-create-buffer :around 'nasy/desktop-time-buffer-create)

(gsetq kill-ring-max 300)

(gsetq history-length 3000
       history-delete-duplicates t
       savehist-additional-variables
       '(mark-ring
         global-mark-ring
         search-ring
         regexp-search-ring
         extended-command-history)
       savehist-autosave-interval 60)

(add-hook #'after-init-hook #'savehist-mode)

(straight-use-package 'session)
(use-package session
  :defer    t
  :hook ((after-init . session-initialize))
  :init
  (gsetq session-save-file (no-littering-expand-var-file-name ".session")
         session-name-disable-regexp "\\(?:\\`'/tmp\\|\\.git/[A-Z_]+\\'\\)"
         session-save-file-coding-system 'utf-8
         desktop-globals-to-save
         (append '((comint-input-ring        . 50)
                   (compile-history          . 30)
                   desktop-missing-file-warning
                   (dired-regexp-history     . 20)
                   (extended-command-history . 30)
                   (face-name-history        . 20)
                   (file-name-history        . 100)
                   (grep-find-history        . 30)
                   (grep-history             . 30)
                   (ivy-history              . 100)
                   (magit-revision-history   . 50)
                   (minibuffer-history       . 50)
                   (org-clock-history        . 50)
                   (org-refile-history       . 50)
                   (org-tags-history         . 50)
                   (query-replace-history    . 60)
                   (read-expression-history  . 60)
                   (regexp-history           . 60)
                   (regexp-search-ring       . 20)
                   register-alist
                   (search-ring              . 20)
                   (shell-command-history    . 50)
                   tags-file-name
                   tags-table-list
                   kill-ring))))

(straight-use-package 'super-save)
(use-package super-save
  :ghook 'after-init-hook
  :gfhook '(lambda () (remove-hook #'mouse-leave-buffer-hook #'super-save-command))
  :init (gsetq super-save-auto-save-when-idle nil
               super-save-remote-files        nil
               super-save-hook-triggers       nil
               super-save-triggers
               '(ibuffer other-window windmove-up windmove-down windmove-left windmove-right next-buffer previous-buffer)))

(straight-use-package 'default-text-scale)
(use-package default-text-scale
  :commands default-text-scale-mode
  :ghook 'after-init-hook)

(defun radian-reload-init ()
  "Reload init.el."
  (interactive)
  (straight-transaction
    (straight-mark-transaction-as-init)
    (message "Reloading init.el...")
    (load user-init-file nil 'nomessage)
    (message "Reloading init.el... done.")))

(defun radian-eval-buffer ()
  "Evaluate the current buffer as Elisp code."
  (interactive)
  (message "Evaluating %s..." (buffer-name))
  (straight-transaction
    (if (null buffer-file-name)
        (eval-buffer)
      (when (string= buffer-file-name user-init-file)
        (straight-mark-transaction-as-init))
      (load-file buffer-file-name)))
  (message "Evaluating %s... done." (buffer-name)))

(defun nasy:insert-current-date ()
  "Insert current date."
  (interactive)
  (insert (shell-command-to-string "echo -n $(date +'%b %d, %Y')")))

(defun nasy:insert-current-filename ()
  "Insert current buffer filename."
  (interactive)
  (insert (file-relative-name buffer-file-name)))

(defun posframe-poshandler-frame-top-center (info)
  (cons (/ (- (plist-get info :parent-frame-width)
              (plist-get info :posframe-width))
           2)
        (round (* 0.02 (x-display-pixel-height)))))

(straight-use-package 'ace-window)
(use-package ace-window
  :bind (("M-o" . ace-window))
  :config
  (set-face-attribute
   'aw-leading-char-face nil
   :foreground "deep sky blue"
   :weight 'bold
   :height 3.0)
  (set-face-attribute
   'aw-mode-line-face nil
   :inherit 'mode-line-buffer-id
   :foreground "lawn green")
  (gsetq-default cursor-in-non-selected-windows 'hollow)
  (gsetq aw-reverse-frame-list t
         aw-keys '(?a ?s ?d ?f ?j ?k ?l)
         aw-dispatch-always t
         aw-dispatch-alist
         '((?w hydra-window-size/body)
           (?o hydra-window-scroll/body)
           (?\; hydra-frame-window/body)
           (?0 delete-frame)
           (?1 delete-other-frames)
           (?2 make-frame)
           (?x aw-delete-window "Ace - Delete Window")
           (?c aw-swap-window "Ace - Swap Window")
           (?n aw-flip-window)
           (?v aw-split-window-vert "Ace - Split Vert Window")
           (?h aw-split-window-horz "Ace - Split Horz Window")
           (?\- aw-split-window-vert "Ace - Split Vert Window")
           (?\| aw-split-window-horz "Ace - Split Horz Window")
           (?m delete-other-windows "Ace - Maximize Window")
           (?g delete-other-windows)
           (?b balance-windows)
           (?u (lambda ()
                 (progn
                   (winner-undo)
                   (setq this-command 'winner-undo)))
               (?r winner-redo))))
  (with-eval-after-load 'hydra
    (defhydra hydra-window-size (:color violet)
      "Windows size"
      ("h" shrink-window-horizontally "shrink horizontal")
      ("j" shrink-window "shrink vertical")
      ("k" enlarge-window "enlarge vertical")
      ("l" enlarge-window-horizontally "enlarge horizontal"))
    (defhydra hydra-window-scroll (:color violet)
      "Scroll other window"
      ("n" joe-scroll-other-window "scroll")
      ("p" joe-scroll-other-window-down "scroll down"))
    (defhydra hydra-frame-window (:color violet :hint nil)
      "
^Delete^                       ^Frame resize^             ^Window^                Window Size^^^^^^   ^Text^                         (__)
_0_: delete-frame              _g_: resize-frame-right    _t_: toggle               ^ ^ _k_ ^ ^        _K_                           (oo)
_1_: delete-other-frames       _H_: resize-frame-left     _e_: ace-swap-win         _h_ ^+^ _l_        ^+^                     /------\\/
_2_: make-frame                _F_: fullscreen            ^ ^                       ^ ^ _j_ ^ ^        _J_                    / |    ||
_d_: kill-and-delete-frame     _n_: new-frame-right       _w_: ace-delete-window    _b_alance^^^^      ^ ^                   *  /\\---/\\  ~~  C-x f ;
"
      ("0" delete-frame :exit t)
      ("1" delete-other-frames :exit t)
      ("2" make-frame  :exit t)
      ("b" balance-windows)
      ("d" kill-and-delete-frame :exit t)
      ("e" ace-swap-window)
      ("F" toggle-frame-fullscreen)   ;; is <f11>
      ("g" resize-frame-right :exit t)
      ("H" resize-frame-left :exit t)  ;; aw-dispatch-alist uses h, I rebind here so hjkl can be used for size
      ("n" new-frame-right :exit t)
      ("r" reverse-windows)
      ("t" toggle-window-spilt)
      ("w" ace-delete-window :exit t)
      ("x" delete-frame :exit t)
      ("K" text-scale-decrease)
      ("J" text-scale-increase)
      ("h" shrink-window-horizontally)
      ("k" shrink-window)
      ("j" enlarge-window)
      ("l" enlarge-window-horizontally)))
  (ace-window-display-mode t))

(straight-use-package 'switch-window)
(use-package switch-window
  :init (gsetq-default switch-window-shortcut-style 'alphabet
                       switch-window-timeout nil)
  :config
  ;; When splitting window, show (other-buffer) in the new window
  (defun split-window-func-with-other-buffer (split-function)
    "Split window with `SPLIT-FUNCTION'."
    (lambda (&optional arg)
      "Split this window and switch to the new window unless ARG is provided."
      (interactive "P")
      (funcall split-function)
      (let ((target-window (next-window)))
        (set-window-buffer target-window (other-buffer))
        (unless arg
          (select-window target-window)))))

  (defun toggle-delete-other-windows ()
    "Delete other windows in frame if any, or restore previous window config."
    (interactive)
    (if (and winner-mode
             (equal (selected-window) (next-window)))
        (winner-undo)
      (delete-other-windows)))

  (defun split-window-horizontally-instead ()
    "Kill any other windows and re-split such that the current window is on the top half of the frame."
    (interactive)
    (let ((other-buffer (and (next-window) (window-buffer (next-window)))))
      (delete-other-windows)
      (split-window-horizontally)
      (when other-buffer
        (set-window-buffer (next-window) other-buffer))))

  (defun split-window-vertically-instead ()
    "Kill any other windows and re-split such that the current window is on the left half of the frame."
    (interactive)
    (let ((other-buffer (and (next-window) (window-buffer (next-window)))))
      (delete-other-windows)
      (split-window-vertically)
      (when other-buffer
        (set-window-buffer (next-window) other-buffer))))

  ;; Borrowed from http://postmomentum.ch/blog/201304/blog-on-emacs
  (defun nasy/split-window()
    "Split the window to see the most recent buffer in the other window.
  Call a second time to restore the original window configuration."
    (interactive)
    (if (eq last-command 'nasy-split-window)
        (progn
          (jump-to-register :nasy-split-window)
          (setq this-command 'nasy-unsplit-window))
      (window-configuration-to-register :nasy/split-window)
      (switch-to-buffer-other-window nil)))

  (general-define-key
   :prefix "C-x"
   "1" 'toggle-delete-other-windows
   "2" (split-window-func-with-other-buffer 'split-window-vertically)
   "3" (split-window-func-with-other-buffer 'split-window-horizontally)
   "|" 'split-window-horizontally-instead
   "_" 'split-window-vertically-instead
   "x" 'nasy/split-window
   "o" 'switch-window))

(straight-use-package 'disable-mouse)

(setq enable-recursive-minibuffers t)

(minibuffer-depth-indicate-mode)

;; https://www.reddit.com/r/emacs/comments/4d8gvt/how_do_i_automatically_close_the_minibuffer_after/
(defun helper/kill-minibuffer ()
  "Exit the minibuffer if it is active."
  (when (and (>= (recursion-depth) 1)
           (active-minibuffer-window))
    (abort-recursive-edit)))

(add-hook #'mouse-leave-buffer-hook #'helper/kill-minibuffer)

(straight-use-package 'scratch)

(straight-use-package 'company)
(use-package company
  :init
  (gsetq company-minimum-prefix-length .2
         company-require-match 'company-explicit-action-p
         company-transformers '(company-sort-by-backend-importance)
         company-tooltip-align-annotations t
         company-dabbrev-other-buffers 'all
         company-dabbrev-downcase nil
         company-dabbrev-ignore-case t
         company-gtags-executable "gtags")
  :hook ((after-init . global-company-mode))
  :bind (("M-/"   . company-complete)
         ("C-M-/" . company-files)
         :map company-mode-map
         ("M-/"   . company-other-backend)
         :map company-active-map
         ("<tab>" . company-complete)
         ("M-/"   . company-other-backend)
         ("C-n"   . company-select-next)
         ("C-p"   . company-select-previous))
  :config
  (defvar my-prev-whitespace-mode nil)
  (make-variable-buffer-local 'my-prev-whitespace-mode)
  (defun pre-popup-draw ()
    "Turn off whitespace mode before showing company complete tooltip"
    (if whitespace-mode
        (progn
          (setq my-prev-whitespace-mode t)
          (whitespace-mode -1)
          (setq my-prev-whitespace-mode t))))
  (defun post-popup-draw ()
    "Restore previous whitespace mode after showing company tooltip"
    (if my-prev-whitespace-mode
        (progn
          (whitespace-mode 1)
          (setq my-prev-whitespace-mode nil))))
  (advice-add 'company-pseudo-tooltip-unhide :before #'pre-popup-draw)
  (advice-add 'company-pseudo-tooltip-hide :after #'post-popup-draw)

  (defun company-backend-with-yas (backends)
    "Add :with company-yasnippet to company BACKENDS.
  Taken from https://github.com/syl20bnr/spacemacs/pull/179."
    (if (and (listp backends) (memq 'company-yasnippet backends))
        backends
      (append (if (consp backends)
                  backends
                (list backends))
              '(:with company-yasnippet))))
  ;; add yasnippet to all backends
  (gsetq company-backends
         (mapcar #'company-backend-with-yas company-backends))
  :diminish company-mode)

(straight-use-package 'company-try-hard)
(use-package company-try-hard
  :bind (:map company-active-map
         ("C-z" . company-try-hard)))

(straight-use-package 'company-quickhelp)
(use-package company-quickhelp
  :after company
  :bind (:map company-active-map
              ("C-c h" . company-quickhelp-manual-begin))
  :ghook #'after-init-hook
  :init (gsetq pos-tip-use-relative-coordinates t))

(straight-use-package 'company-math)

(straight-use-package 'company-flx)
(use-package company-flx
  :after company
  :ghook #'after-init-hook)

(when *c-box*
  (straight-use-package 'company-box)
  (use-package company-box
    :defer    t
    :after (all-the-icons company)
    :init
    (setq company-box-icons-alist 'company-box-icons-all-the-icons)
    :ghook 'company-mode-hook
    :config
    (setq company-box-backends-colors '((company-lsp      . "#e0f9b5")
                                        (company-elisp    . "#e0f9b5")
                                        (company-files    . "#ffffc2")
                                        (company-keywords . "#ffa5a5")
                                        (company-capf     . "#bfcfff")
                                        (company-dabbrev  . "#bfcfff")))
    (setq company-box-icons-unknown (concat (all-the-icons-material "find_in_page") " "))
    (setq company-box-icons-elisp
          (list
           (concat (all-the-icons-faicon "tag") " ")
           (concat (all-the-icons-faicon "cog") " ")
           (concat (all-the-icons-faicon "cube") " ")
           (concat (all-the-icons-material "color_lens") " ")))
    (setq company-box-icons-yasnippet (concat (all-the-icons-faicon "bookmark") " "))
    (setq company-box-icons-lsp
          `((1 .  ,(concat (all-the-icons-faicon   "text-height")    " ")) ;; Text
            (2 .  ,(concat (all-the-icons-faicon   "tags")           " ")) ;; Method
            (3 .  ,(concat (all-the-icons-faicon   "tag" )           " ")) ;; Function
            (4 .  ,(concat (all-the-icons-faicon   "tag" )           " ")) ;; Constructor
            (5 .  ,(concat (all-the-icons-faicon   "cog" )           " ")) ;; Field
            (6 .  ,(concat (all-the-icons-faicon   "cog" )           " ")) ;; Variable
            (7 .  ,(concat (all-the-icons-faicon   "cube")           " ")) ;; Class
            (8 .  ,(concat (all-the-icons-faicon   "cube")           " ")) ;; Interface
            (9 .  ,(concat (all-the-icons-faicon   "cube")           " ")) ;; Module
            (10 . ,(concat (all-the-icons-faicon   "cog" )           " ")) ;; Property
            (11 . ,(concat (all-the-icons-material "settings_system_daydream") " ")) ;; Unit
            (12 . ,(concat (all-the-icons-faicon   "cog" )           " ")) ;; Value
            (13 . ,(concat (all-the-icons-material "storage")        " ")) ;; Enum
            (14 . ,(concat (all-the-icons-material "closed_caption") " ")) ;; Keyword
            (15 . ,(concat (all-the-icons-faicon   "bookmark")       " ")) ;; Snippet
            (16 . ,(concat (all-the-icons-material "color_lens")     " ")) ;; Color
            (17 . ,(concat (all-the-icons-faicon   "file-text-o")    " ")) ;; File
            (18 . ,(concat (all-the-icons-material "refresh")        " ")) ;; Reference
            (19 . ,(concat (all-the-icons-faicon   "folder-open")    " ")) ;; Folder
            (20 . ,(concat (all-the-icons-material "closed_caption") " ")) ;; EnumMember
            (21 . ,(concat (all-the-icons-faicon   "square")         " ")) ;; Constant
            (22 . ,(concat (all-the-icons-faicon   "cube")           " ")) ;; Struct
            (23 . ,(concat (all-the-icons-faicon   "calendar")       " ")) ;; Event
            (24 . ,(concat (all-the-icons-faicon   "square-o")       " ")) ;; Operator
            (25 . ,(concat (all-the-icons-faicon   "arrows")         " "))) ;; TypeParameter
          )))

(use-package dired
  :init
  (let ((gls (executable-find "gls")))
    (when gls (setq insert-directory-program gls)))
  (setq dired-recursive-deletes 'top)
  :bind (:map dired-mode-map
              ([mouse-2] . dired-find-file             )
              ("C-c C-p" . wdired-change-to-wdired-mode)))

(straight-use-package 'diredfl)
(use-package diredfl
  :after dired
  :hook ((after-init . diredfl-global-mode)))

(use-package uniquify
  :init  ;; nicer naming of buffers for files with identical names
  (gsetq uniquify-buffer-name-style   'reverse
         uniquify-separator           " • "
         uniquify-after-kill-buffer-p t
         uniquify-ignore-buffers-re   "^\\*"))

(straight-use-package 'diff-hl)
(use-package diff-hl
  :after dired
  :hook ((dired-mode . diff-hl-dired-mode)
         (magit-post-refresh . diff-hl-magit-post-refresh)))

(straight-use-package 'dired-hacks-utils)

(straight-use-package 'dired-filter)
(use-package dired-filter
  :after    dired
  :bind (:map dired-mode-map
              ("/" . dired-filter-map))
  :hook ((dired-mode . dired-filter-mode)
         (dired-mode . dired-filter-group-mode))
  :init (gsetq dired-filter-revert 'never
               dired-filter-group-saved-groups
               '(("default"
                  ("Git"
                   (directory . ".git")
                   (file . ".gitignore"))
                  ("Directory"
                   (directory))
                  ("PDF"
                   (extension . "pdf"))
                  ("LaTeX"
                   (extension "tex" "bib"))
                  ("Source"
                   (extension "c" "cpp" "hs" "rb" "py" "r" "cs" "el" "lisp" "html" "js" "css"))
                  ("Doc"
                   (extension "md" "rst" "txt"))
                  ("Org"
                   (extension . "org"))
                  ("Archives"
                   (extension "zip" "rar" "gz" "bz2" "tar"))
                  ("Images"
                   (extension "jpg" "JPG" "webp" "png" "PNG" "jpeg" "JPEG" "bmp" "BMP" "TIFF" "tiff" "gif" "GIF"))))))

(when (executable-find "avfsd")
  (straight-use-package 'dired-avfs))

(straight-use-package 'dired-rainbow)
(use-package dired-rainbow
  :after dired
  :config
  (dired-rainbow-define-chmod directory "#6cb2eb" "d.*")
  (dired-rainbow-define html        "#eb5286" ("css" "less" "sass" "scss" "htm" "html" "jhtm" "mht" "eml" "mustache" "xhtml"))
  (dired-rainbow-define xml         "#f2d024" ("xml" "xsd" "xsl" "xslt" "wsdl" "bib" "json" "msg" "pgn" "rss" "yaml" "yml" "rdata"))
  (dired-rainbow-define document    "#9561e2" ("docm" "doc" "docx" "odb" "odt" "pdb" "pdf" "ps" "rtf" "djvu" "epub" "odp" "ppt" "pptx"))
  (dired-rainbow-define markdown    "#ffed4a" ("org" "etx" "info" "markdown" "md" "mkd" "nfo" "pod" "rst" "tex" "textfile" "txt"))
  (dired-rainbow-define database    "#6574cd" ("xlsx" "xls" "csv" "accdb" "db" "mdb" "sqlite" "nc"))
  (dired-rainbow-define media       "#de751f" ("mp3" "mp4" "MP3" "MP4" "avi" "mpeg" "mpg" "flv" "ogg" "mov" "mid" "midi" "wav" "aiff" "flac"))
  (dired-rainbow-define image       "#f66d9b" ("tiff" "tif" "cdr" "gif" "ico" "jpeg" "jpg" "png" "psd" "eps" "svg"))
  (dired-rainbow-define log         "#c17d11" ("log"))
  (dired-rainbow-define shell       "#f6993f" ("awk" "bash" "bat" "sed" "sh" "zsh" "vim"))
  (dired-rainbow-define interpreted "#38c172" ("py" "ipynb" "rb" "pl" "t" "msql" "mysql" "pgsql" "sql" "r" "clj" "cljs" "scala" "js"))
  (dired-rainbow-define compiled    "#4dc0b5" ("asm" "cl" "lisp" "el" "c" "h" "c++" "h++" "hpp" "hxx" "m" "cc" "cs" "cp" "cpp" "go" "f" "for" "ftn" "f90" "f95" "f03" "f08" "s" "rs" "hi" "hs" "pyc" ".java"))
  (dired-rainbow-define executable  "#8cc4ff" ("exe" "msi"))
  (dired-rainbow-define compressed  "#51d88a" ("7z" "zip" "bz2" "tgz" "txz" "gz" "xz" "z" "Z" "jar" "war" "ear" "rar" "sar" "xpi" "apk" "xz" "tar"))
  (dired-rainbow-define packaged    "#faad63" ("deb" "rpm" "apk" "jad" "jar" "cab" "pak" "pk3" "vdf" "vpk" "bsp"))
  (dired-rainbow-define encrypted   "#ffed4a" ("gpg" "pgp" "asc" "bfe" "enc" "signature" "sig" "p12" "pem"))
  (dired-rainbow-define fonts       "#6cb2eb" ("afm" "fon" "fnt" "pfb" "pfm" "ttf" "otf"))
  (dired-rainbow-define partition   "#e3342f" ("dmg" "iso" "bin" "nrg" "qcow" "toast" "vcd" "vmdk" "bak"))
  (dired-rainbow-define vc          "#0074d9" ("git" "gitignore" "gitattributes" "gitmodules"))
  (dired-rainbow-define-chmod executable-unix "#38c172" "-.*x.*"))

(straight-use-package 'dired-subtree)

(straight-use-package 'dired-ranger)

(straight-use-package 'dired-narrow)
(use-package dired-narrow
  :after    dired
  :bind (:map dired-narrow-map
              ("<down>"  . dired-narrow-next-file)
              ("<up>"    . dired-narrow-previous-file)
              ("<right>" . dired-narrow-enter-directory)))

(straight-use-package 'dired-collapse)
(use-package dired-collapse
  :ghook 'dired-mode-hook)

(straight-use-package 'unfill)
(use-package unfill
  :bind (("M-q" . unfill-toggle)))

(straight-use-package 'visual-fill-column)
(use-package visual-fill-column
  :preface
  (defun maybe-adjust-visual-fill-column ()
    "Readjust visual fill column when the global font size is modified.
This is helpful for writeroom-mode, in particular."
    (if visual-fill-column-mode
        (add-hook 'after-setting-font-hook 'visual-fill-column--adjust-window nil t)
      (remove-hook 'after-setting-font-hook 'visual-fill-column--adjust-window t)))
  :hook ((visual-line-mode        . visual-fill-column-mode        )
         (visual-fill-column-mode . maybe-adjust-visual-fill-column)))

(straight-use-package 'cl-lib-highlight)
(with-eval-after-load 'emacs-lisp-mode
  (use-package cl-lib-highlight
    :config
    (cl-lib-highlight-initialize)))

(straight-use-package 'color-identifiers-mode)
(use-package color-identifiers-mode
  :defer t
  :hook ((prog-mode . color-identifiers-mode)))

(straight-use-package 'hl-line)
(use-package hl-line
  :defer t
  :hook ((after-init . global-hl-line-mode)))

(straight-use-package 'highlight-indent-guides)
(use-package highlight-indent-guides
  :init (gsetq highlight-indent-guides-responsive 'stack)
  :ghook '(prog-mode-hook text-mode-hook org-mode-hook))

;; (straight-use-package 'highlight-numbers)
;; (use-package highlight-numbers
;;   :disabled t
;;   :ghook '(after-init-hook prog-mode-hook text-mode-hook org-mode-hook))

(straight-use-package 'rainbow-mode)
(use-package rainbow-mode
  :hook (((after-init
           text-mode
           org-mode
           css-mode
           html-mode
           prog-mode). rainbow-mode))
  :diminish rainbow-mode)

(straight-use-package 'helm)
(use-package helm-config
  :diminish helm-mode
  :commands nasy/helm
  :hook ((after-init . helm-mode)
         (after-init . helm-autoresize-mode))
  :init
  (gsetq helm-M-x-fuzzy-match        t
         helm-buffers-fuzzy-matching t
         helm-recentf-fuzzy-match    t
         helm-imenu-fuzzy-match      t
         helm-locate-fuzzy-match     t
         helm-apropos-fuzzy-match    t
         helm-lisp-fuzzy-completion  t
         helm-allow-mouse            t
         helm-follow-mode-persistent t
         helm-ff-lynx-style-map      t)

  (when (executable-find "curl")
    (gsetq helm-google-suggest-use-curl-p t))

  (gsetq helm-split-window-in-side-p           t
         helm-move-to-line-cycle-in-source     nil
         helm-ff-search-library-in-sexp        t
         helm-scroll-amount                    8
         helm-ff-file-name-history-use-recentf t
         helm-echo-input-in-header-line        t
         helm-source-names-using-follow        '("Buffers" "kill-buffer" "Occur"))

  (gsetq helm-grep-ag-command
         "rg --color=always --colors 'match:fg:black' --colors 'match:bg:yellow' --smart-case --no-heading --line-number %s %s %s"
         helm-grep-ag-pipe-cmd-switches
         '("--colors 'match:fg:black'" "--colors 'match:bg:yellow'"))

  (general-define-key
   "M-x"     'helm-M-x
   "M-y"     'helm-show-kill-ring
   "M-b"     'nasy/helm
   "C-o"     'helm-occur
   "C-s"     'helm-occur
   "C-x C-f" 'helm-find-files)
  (general-define-key
   :prefix "C-x c"
   "x"   'helm-register
   "g"   'helm-google-suggest
   "M-:" 'helm-eval-expression-with-eldoc)
  (general-define-key
   :keymaps 'helm-map
   "<tab>" 'helm-execute-persistent-action ; rebind tab to run persistent action
   "C-i"   'helm-execute-persistent-action ; make TAB works in terminal
   "C-z"   'helm-select-action) ; list actions using C-z
  (general-define-key
   :keymaps 'shell-mode-map
   "C-c C-l" 'helm-comint-input-ring)
  (general-define-key
   :keymaps 'minibuffer-local-map
   "C-c C-l" 'helm-minibuffer-history)

  :config
  (add-to-list 'helm-sources-using-default-as-input 'helm-source-man-pages)

  (require 'helm-buffers)
  (require 'helm-for-files)

  (defun nasy/helm ()
    (interactive)
    (let ((helm-ff-transformer-show-only-basename nil)
          helm-source-list)
      (unless helm-source-buffers-list
        (setq helm-source-buffers-list
              (helm-make-source "Buffers" 'helm-source-buffers)))
      (cond (
             ;; Just add helm-source-projectile-* in list when current place in project.
             (projectile-project-p)
             (setq helm-source-list
                   '(
                     ;; helm-source-awesome-tab-group
                     helm-source-projectile-buffers-list
                     helm-source-buffers-list
                     helm-source-recentf
                     helm-source-projectile-files-list)))

            (t
             (setq helm-source-list
                   '(
                     ;; helm-source-awesome-tab-group
                     helm-source-buffers-list
                     helm-source-recentf))))
      (helm-other-buffer helm-source-list "*helm search*"))))

(use-package helm-org
  :defer t
  :config
  (cl-defun helm-org-headings-in-buffer ()
    (interactive)
    (helm :sources (helm-source-org-headings-for-files
                    (list (projectile-completing-read
                           "File to look at headings from: "
                           (projectile-all-project-files))))
          :candidate-number-limit 99999
          :buffer "*helm org inbuffer*")))

(straight-use-package 'helm-company)
(use-package helm-company
  :defer t
  :bind (:map
         company-mode-map ("C-:" . helm-company)
         :map
         company-active-map ("C-:" . helm-company)))

(use-package helm-eshell
  :defer t
  :bind (:map eshell-mode-map
              ("C-c C-l" . helm-eshell-history)))

(straight-use-package 'helm-descbinds)
(use-package helm-descbinds
  :defer t
  :hook ((after-init . helm-descbinds-mode)))

(straight-use-package 'helm-projectile)
(use-package helm-projectile
  :defer t
  :hook ((after-init . helm-projectile-on))
  :init (gsetq projectile-completion-system 'helm))

(straight-use-package 'helm-ag)
(use-package helm-ag
  :defer t
  :init (gsetq  ;; brew install rg
         helm-ag-base-command         "rg --no-heading --smart-case"
         helm-ag-fuzzy-match          t
         helm-ag-use-grep-ignore-list t
         helm-ag-use-agignore         t))

(straight-use-package 'helm-dash)
(use-package helm-dash
  :defer t
  :init (gsetq helm-dash-docsets-path "~/.docsets"))

(straight-use-package 'helm-ls-git)
(use-package helm-ls-git
  :defer t
  :bind (("C-<f6>"   . helm-ls-git-ls)
         ("C-x g"    . helm-ls-git-ls)
         ("C-x C-d"  . helm-browse-project)))

(use-package ibuffer
  :bind (("C-x C-b" . ibuffer))
  :init
  (gsetq ibuffer-saved-filter-groups
         '(("Normal"
            ("Dired"      (mode . dired-mode))
            ("Emacs"     (or
                          (name . "^\\*dashboard\\*$" )
                          (name . "^\\*scratch\\*$"   )
                          (name . "^\\*Messages\\*$"  )
                          (name . "^\\*Backtrace\\*$" )))
            ("Term"       (mode . vterm-mode))
            ("Text"      (or
                          (mode . org-mode)
                          (mode . markdown)
                          (mode . rst-mode)
                          (mode . text-mode)))
            ("TeX"        (mode . tex-mode))
            ("Languages" (or
                          (mode . emacs-lisp-mode)
                          (mode . haskell-mode)
                          (mode . javascript-mode)
                          (mode . lisp-mode)
                          (mode . python-mode)
                          (mode . ruby-mode)
                          (mode . rust-mode)
                          (mode . html-mode)
                          (mode . css-mode)
                          (mode . prog-mode)))
            ("GNUs"      (or
                          (mode . message-mode)
                          (mode . bbdb-mode)
                          (mode . mail-mode)
                          (mode . gnus-group-mode)
                          (mode . gnus-summary-mode)
                          (mode . gnus-article-mode)
                          (name . "^\\.bbdb$")
                          (name . "^\\.newsrc-dribble")))
            ("Magit"      (name . "^magit"))
            ("Help"      (or
                          (name . "^\\*Help\\*$")
                          (name . "^\\*Apropos\\*$")
                          (name . "^\\*info\\*$")
                          (name . "^\\*helpful")))
            ("Custom"    (or
                          (mode . custom-mode)
                          (name . "^\\*Customize")))
            ("Helm"       (mode . helm-major-mode))
            ))
         ibuffer-show-empty-filter-groups nil
         ibuffer-default-sorting-mode     'filename/process)
  :hook ((ibuffer-mode . (lambda () (ibuffer-switch-to-saved-filter-groups "Normal")))))

(straight-use-package 'ibuffer-vc)

(use-package ibuffer
  :defer t
  :config
  (define-ibuffer-column size-h
    (:name "Size" :inline t)
    (file-size-human-readable (buffer-size)))
  (setq
   ibuffer-formats
   '((mark modified read-only vc-status-mini " "
           (name 22 22 :left :elide)
           " "
           (size-h 9 -1 :right)
           " "
           (mode 12 12 :left :elide)
           " "
           vc-relative-file)
     (mark modified read-only vc-status-mini " "
           (name 22 22 :left :elide)
           " "
           (size-h 9 -1 :right)
           " "
           (mode 14 14 :left :elide)
           " "
           (vc-status 12 12 :left)
           " "
           vc-relative-file))))

(straight-use-package 'smartparens)
(use-package smartparens-config
  :hook ((after-init . show-smartparens-global-mode)
         (after-init . smartparens-global-mode))
  :init (gsetq sp-hybrid-kill-entire-symbol nil))

(straight-use-package 'parinfer)
(use-package parinfer
  :bind (("C-," . parinfer-toggle-mode))
  :init (gsetq parinfer-extensions
               '(defaults       ; should be included.
                 pretty-parens  ; different paren styles for different modes.
                 ;; evil           ; If you use Evil.
                 ;; lispy          ; If you use Lispy. With this extension, you should install Lispy and do not enable lispy-mode directly.
                 ;; paredit        ; Introduce some paredit commands.
                 smart-tab      ; C-b & C-f jump positions and smart shift with tab & S-tab.
                 smart-yank))   ; Yank behavior depend on mode.
  :ghook lisp-modes-hooks)

(straight-use-package 'rainbow-delimiters)
(use-package rainbow-delimiters
  :ghook '(prog-mode-hook text-mode-hook org-src-mode-hook))

(straight-use-package 'highlight-parentheses)
(use-package highlight-parentheses
  :init (gsetq hl-paren-highlight-adjacent t)
  :hook ((after-init . global-highlight-parentheses-mode)))

(straight-use-package 'pretty-mode)
(use-package pretty-mode
  :commands (turn-on-pretty-mode global-prettify-symbols-mode)
  :hook (((text-mode
           org-mode)  . turn-on-pretty-mode)
         (after-init  . global-prettify-symbols-mode)
         (prog-mode . (lambda () (mapc (lambda (pair) (push pair prettify-symbols-alist))
                                  '(;; Data Type             P N
                                    ("Float"  . #x211d)  ;; ℝxxxx
                                    ("float"  . #x211d)  ;; ℝxxx
                                    ("Int"    . #x2124)  ;; ℤxxx
                                    ("int"    . #x2124)  ;; 𝕫xxx
                                    ;; ("String" . #x1d57e)  ;; 𝕊 𝕾
                                    ;; ("string" . #x1d598)  ;; 𝕤 𝖘
                                    ;; ("str"    . #x1d598)  ;; 𝕤 𝖘
                                    ("String" . (#x1d54a (Br . Bl) #x2006))  ;; 𝕊 xxxxxx
                                    ("string" . (#x1d564 (Br . Bl) #x2006))  ;; 𝕤 xxxxxx
                                    ("str"    . (#x1d564 (Br . Bl) #x2006))  ;; 𝕤 xxxx
                                    ("Char"   . #x2102)   ;; ℂx
                                    ("char"   . (#x1d554 (Br . Bl) #x2006))  ;; 𝕔 x

                                    ("False"  . #x1d53d)  ;; 𝕱 𝔽
                                    ("True"   . #x1d54b)  ;; 𝕿 𝕋

                                    ("Any"    . #x2203)  ;; ∃
                                    ("any"    . #x2203)  ;; ∃
                                    ("any_"   . #x2203)  ;; ∃
                                    ("And"    . #x22c0)  ;; ⋀
                                    ("and"    . #x22cf)  ;; ⋏
                                    ("Or"     . #x22c1)  ;; ⋁
                                    ("or"     . #x22cE)  ;; ⋎
                                    ("not"    . #x00ac)  ;; ¬
                                    ("not_"   . #x00ac)  ;; ¬

                                    ("All"    . #x2200)  ;; ∀
                                    ("all"    . #x2200)  ;; ∀
                                    ("all_"   . #x2200)  ;; ∀
                                    ("for"    . #x2200)  ;; ∀
                                    ("forall" . #x2200)  ;; ∀
                                    ("forM"   . #x2200)  ;; ∀

                                    ("pi"     . #x03c0)  ;; π

                                    ("sum"    . #x2211)  ;; ∑
                                    ("Sum"    . #x2211)  ;; ∑
                                    ("Product" . #x220F) ;; ∏
                                    ("product" . #x220F) ;; ∏

                                    ("None"   . #x2205)  ;; ∅
                                    ("none"   . #x2205)  ;; ∅

                                    ("in"     . #x2286)  ;; ⊆
                                    ("`elem`" . #x2286)  ;; ⊆
                                    ("not in"    . #x2288)  ;; ⊈
                                    ("`notElem`" . #x2288)  ;; ⊈

                                    ("return" . (#x21d2 (Br . Bl) #x2006 (Br . Bl) #x2004))  ;; ⇒  x
                                    ("yield"  . (#x21d4 (Br . Bl) #x2004))  ;; ⇔ x
                                    ("pure"   . (#x21f0 (Br . Bl)))))))          ;; ⇰ x

         ((prog-mode
           emacs-lisp-mode
           org-mode) . (lambda () (mapc (lambda (pair) (push pair prettify-symbols-alist))
                                   '(;; Global
                                     ;; Pipes
                                     ("<|"  . (?\s (Br . Bl) #Xe14d))
                                     ("<>"  . (?\s (Br . Bl) #Xe15b))
                                     ("<|>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe14e))
                                     ("|>"  . (?\s (Br . Bl) #Xe135))

                                     ;; Brackets
                                     ("<*"  . (?\s (Br . Bl) #Xe14b))
                                     ("<*>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe14c))
                                     ("*>"  . (?\s (Br . Bl) #Xe104))
                                     ("<$"  . (?\s (Br . Bl) #Xe14f))
                                     ("<$>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe150))
                                     ("$>"  . (?\s (Br . Bl) #Xe137))
                                     ("<+"  . (?\s (Br . Bl) #Xe155))
                                     ("<+>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe156))
                                     ("+>"  . (?\s (Br . Bl) #Xe13a))
                                     ("[]"  . (#x2005 (Br . Bl) #x1d731 (Br . Bl) #x2005))

                                     ;; Equality
                                     ("=/="  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe143))
                                     ("/="   . (?\s (Br . Bl) #Xe12c))
                                     ("/=="  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe12d))
                                     ("/==>" . (?\s (Br . Bl) ?\s (Br . Bl) ?\s (Br . Bl) #Xe13c))
                                     ("!==>" . (?\s (Br . Bl) ?\s (Br . Bl) ?\s (Br . Bl) #Xe13c))
                                     ;; Special
                                     ("||="  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe133))
                                     ("|="   . (?\s (Br . Bl) #Xe134))
                                     ("~="   . (?\s (Br . Bl) #Xe166))
                                     ("^="   . (?\s (Br . Bl) #Xe136))
                                     ("=:="  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe13b))

                                     ;; Comparisons
                                     ("</"   . (?\s (Br . Bl) #Xe162))
                                     ("</>"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe163))

                                     ;; Shifts
                                     ("=>>"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe147))
                                     ("->>"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe147))
                                     (">>>"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe14a))
                                     (">>>"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe14a))
                                     ("=<<"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe15c))
                                     ("-<<"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe15c))
                                     ("<<<"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe15f))

                                     ;; Dots
                                     (".-"   . (?\s (Br . Bl) #Xe122))
                                     (".="   . (?\s (Br . Bl) #Xe123))
                                     ("..<"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe125))

                                     ;; Hashes
                                     ("#{"   . (?\s (Br . Bl) #Xe119))
                                     ("#("   . (?\s (Br . Bl) #Xe11e))
                                     ("#_"   . (?\s (Br . Bl) #Xe120))
                                     ("#_("  . (?\s (Br . Bl) #Xe121))
                                     ("#?"   . (?\s (Br . Bl) #Xe11f))
                                     ("#["   . (?\s (Br . Bl) #Xe11a))

                                     ;; REPEATED CHARACTERS
                                     ;; 2-Repeats
                                     ("!!"   . (?\s (Br . Bl) #Xe10d))
                                     ("%%"   . (?\s (Br . Bl) #Xe16a))

                                     ;; 2+3-Repeats
                                     ("##"   . (?\s (Br . Bl) #Xe11b))
                                     ("###"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe11c))
                                     ("####" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe11d))
                                     ("---"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe112))
                                     ("{-"   . (?\s (Br . Bl) #Xe108))
                                     ("-}"   . (?\s (Br . Bl) #Xe110))
                                     ("\\\\" . (?\s (Br . Bl) #Xe106))
                                     ("\\\\\\" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe107))
                                     (".."   . (?\s (Br . Bl) #Xe124))
                                     ("..."  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe126))
                                     ("+++"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe139))
                                     ("//"   . (?\s (Br . Bl) #Xe12f))
                                     ("///"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe130))
                                     ("::"   . (?\s (Br . Bl) #Xe10a))  ;; 
                                     (":::"  . (?\s (Br . Bl) ?\s (Br . Bl) #Xe10b))

                                     ;; Arrows
                                     ;; Direct
                                     ;; ("->"  . (?\s (Br . Bl) #Xe114))  ;; 
                                     ;; ("=>"  . (?\s (Br . Bl) #Xe13f))
                                     ("->>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe115))
                                     ("=>>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe140))
                                     ("<<-" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe15d))
                                     ("<<=" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe15e))
                                     ("<->" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe154))
                                     ("<=>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe159))
                                     ;; Branches
                                     ("-<"  . (?\s (Br . Bl) #Xe116))
                                     ("-<<" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe117))
                                     (">-"  . (?\s (Br . Bl) #Xe144))
                                     (">>-" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe148))
                                     ("=<<" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe142))
                                     (">=>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe146))
                                     (">>=" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe149))
                                     ("<=<" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe15a))
                                     ;; Squiggly
                                     ("<~"  . (?\s (Br . Bl) #Xe160))
                                     ("<~~" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe161))
                                     ("~>"  . (?\s (Br . Bl) #Xe167))
                                     ("~~>" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe169))
                                     ("-~"  . (?\s (Br . Bl) #Xe118))
                                     ("~-"  . (?\s (Br . Bl) #Xe165))

                                     ;; MISC
                                     ("www" . (?\s (Br . Bl) ?\s (Br . Bl) #Xe100))
                                     ("[email protected]"  . (?\s (Br . Bl) #Xe164))
                                     ("~~"  . (?\s (Br . Bl) #Xe168))
                                     ("?="  . (?\s (Br . Bl) #Xe127))
                                     (":="  . (?\s (Br . Bl) #Xe10c))
                                     ("/>"  . (?\s (Br . Bl) #Xe12e))
                                     ("+"   . #Xe16d)
                                     ("(:"  . (?\s (Br . Bl) #Xe16c))))))


         (python-mode . (lambda ()
                          (mapc (lambda (pair) (push pair prettify-symbols-alist))
                                '(;; Syntax
                                  ;;("def"    . (#x1d521 (Br . Bl) #x1d522 (Br . Bl) #x1d523))
                                  ("def"    . #x1D487)  ;; 𝒇 1 111
                                  ("List"   . #x1d543)  ;; 𝕃 𝕷
                                  ("list"   . (#x1d55d (Br . Bl) #x2006 (Br . Bl) #x2005))  ;; 𝕝   𝖑
                                  ("Dict"   . #x1d53B)  ;; 𝔻 𝕯
                                  ("dict"   . #x1d555)  ;; 𝕕 𝖉
                                  ("Set"    . #x1d61a)  ;; 𝔖 𝘚
                                  ("set"    . #x1d634)  ;; 𝔰 𝘴
                                  ("Tuple"  . #x1d61b)  ;; 𝕋 𝕿 𝘛
                                  ("tuple"  . #x1d635)  ;; 𝕥 𝖙 𝘵

                                  ("Union"  . #x22c3)  ;; ⋃
                                  ("union"  . #x22c3)))))  ;; ⋃

         (haskell-mode . (lambda ()
                           (mapc (lambda (pair) (push pair prettify-symbols-alist))
                                 '(;; Syntax
                                   ("pure" . (#x21f0 (Br . Bl) #x2006))))))) ;; ⇰  x
                                   ;; (" . "  . (?\s (Br . Bl) #x2218 (Br . Bl) ?\s (Br . Bl) #x2006)) ;; ∘

  :config
  (pretty-activate-groups
   '(:sub-and-superscripts :greek :arithmetic))

  (pretty-deactivate-groups
   '(:equality :ordering :ordering-double :ordering-triple
               :arrows :arrows-twoheaded :punctuation
               :logic :sets :arithmetic-double :arithmetic-triple)))

(straight-use-package 'ipretty)
(use-package ipretty
  :defer    t
  :ghook 'after-init-hook)

;; https://github.com/tonsky/FiraCode/wiki/Emacs-instructions
;; This works when using emacs --daemon + emacsclient
(add-hook 'after-make-frame-functions (lambda (frame) (set-fontset-font t '(#Xe100 . #Xe16f) "Fira Code Symbol")))
;; This works when using emacs without server/client
(set-fontset-font t '(#Xe100 . #Xe16f) "Fira Code Symbol")
;; I haven't found one statement that makes both of the above situations work, so I use both for now

(defun pretty-fonts-set-fontsets (CODE-FONT-ALIST)
  "Utility to associate many unicode points with specified `CODE-FONT-ALIST'."
  (--each CODE-FONT-ALIST
    (-let (((font . codes) it))
      (--each codes
        (set-fontset-font nil `(,it . ,it) font)
        (set-fontset-font t `(,it . ,it) font)))))

(defun pretty-fonts--add-kwds (FONT-LOCK-ALIST)
  "Exploits `font-lock-add-keywords'(`FONT-LOCK-ALIST') to apply regex-unicode replacements."
  (font-lock-add-keywords
   nil (--map (-let (((rgx uni-point) it))
               `(,rgx (0 (progn
                           (compose-region
                            (match-beginning 1) (match-end 1)
                            ,(concat "\t" (list uni-point)))
                           nil))))
             FONT-LOCK-ALIST)))

(defmacro pretty-fonts-set-kwds (FONT-LOCK-HOOKS-ALIST)
  "Set regex-unicode replacements to many modes(`FONT-LOCK-HOOKS-ALIST')."
  `(--each ,FONT-LOCK-HOOKS-ALIST
     (-let (((font-locks . mode-hooks) it))
       (--each mode-hooks
         (add-hook it (-partial 'pretty-fonts--add-kwds
                                (symbol-value font-locks)))))))

(defconst pretty-fonts-fira-font
  '(;; OPERATORS
    ;; Pipes
    ("\\(<|\\)" #Xe14d) ("\\(<>\\)" #Xe15b) ("\\(<|>\\)" #Xe14e) ("\\(|>\\)" #Xe135)

    ;; Brackets
    ("\\(<\\*\\)" #Xe14b) ("\\(<\\*>\\)" #Xe14c) ("\\(\\*>\\)" #Xe104)
    ("\\(<\\$\\)" #Xe14f) ("\\(<\\$>\\)" #Xe150) ("\\(\\$>\\)" #Xe137)
    ("\\(<\\+\\)" #Xe155) ("\\(<\\+>\\)" #Xe156) ("\\(\\+>\\)" #Xe13a)

    ;; Equality
    ("\\(!=\\)" #Xe10e) ("\\(!==\\)"         #Xe10f) ("\\(=/=\\)" #Xe143)
    ("\\(/=\\)" #Xe12c) ("\\(/==\\)"         #Xe12d)
    ("\\(===\\)" #Xe13d) ("[^!/]\\(==\\)[^>]" #Xe13c)

    ;; Equality Special
    ("\\(||=\\)"  #Xe133) ("[^|]\\(|=\\)" #Xe134)
    ("\\(~=\\)"   #Xe166)
    ("\\(\\^=\\)" #Xe136)
    ("\\(=:=\\)"  #Xe13b)

    ;; Comparisons
    ("\\(<=\\)" #Xe141) ("\\(>=\\)" #Xe145)
    ("\\(</\\)" #Xe162) ("\\(</>\\)" #Xe163)

    ;; Shifts
    ("[^-=]\\(>>\\)" #Xe147) ("\\(>>>\\)" #Xe14a)
    ("[^-=]\\(<<\\)" #Xe15c) ("\\(<<<\\)" #Xe15f)

    ;; Dots
    ("\\(\\.-\\)"    #Xe122) ("\\(\\.=\\)" #Xe123)
    ("\\(\\.\\.<\\)" #Xe125)

    ;; Hashes
    ("\\(#{\\)"  #Xe119) ("\\(#(\\)"   #Xe11e) ("\\(#_\\)"   #Xe120)
    ("\\(#_(\\)" #Xe121) ("\\(#\\?\\)" #Xe11f) ("\\(#\\[\\)" #Xe11a)

    ;; REPEATED CHARACTERS
    ;; 2-Repeats
    ("\\(||\\)" #Xe132)
    ("\\(!!\\)" #Xe10d)
    ("\\(%%\\)" #Xe16a)
    ("\\(&&\\)" #Xe131)

    ;; 2+3-Repeats
    ("\\(##\\)"       #Xe11b) ("\\(###\\)"          #Xe11c) ("\\(####\\)" #Xe11d)
    ("\\(--\\)"       #Xe111) ("\\(---\\)"          #Xe112)
    ("\\({-\\)"       #Xe108) ("\\(-}\\)"           #Xe110)
    ("\\(\\\\\\\\\\)" #Xe106) ("\\(\\\\\\\\\\\\\\)" #Xe107)
    ("\\(\\.\\.\\)"   #Xe124) ("\\(\\.\\.\\.\\)"    #Xe126)
    ("\\(\\+\\+\\)"   #Xe138) ("\\(\\+\\+\\+\\)"    #Xe139)
    ("\\(//\\)"       #Xe12f) ("\\(///\\)"          #Xe130)
    ("\\(::\\)"       #Xe10a) ("\\(:::\\)"          #Xe10b)

    ;; ARROWS
    ;; Direct
    ("[^-]\\(->\\)" #Xe114) ("[^=]\\(=>\\)" #Xe13f)
    ("\\(<-\\)"     #Xe152)
    ("\\(-->\\)"    #Xe113) ("\\(->>\\)"    #Xe115)
    ("\\(==>\\)"    #Xe13e) ("\\(=>>\\)"    #Xe140)
    ("\\(<--\\)"    #Xe153) ("\\(<<-\\)"    #Xe15d)
    ("\\(<==\\)"    #Xe158) ("\\(<<=\\)"    #Xe15e)
    ("\\(<->\\)"    #Xe154) ("\\(<=>\\)"    #Xe159)

    ;; Branches
    ("\\(-<\\)"  #Xe116) ("\\(-<<\\)" #Xe117)
    ("\\(>-\\)"  #Xe144) ("\\(>>-\\)" #Xe148)
    ("\\(=<<\\)" #Xe142) ("\\(>>=\\)" #Xe149)
    ("\\(>=>\\)" #Xe146) ("\\(<=<\\)" #Xe15a)

    ;; Squiggly
    ("\\(<~\\)" #Xe160) ("\\(<~~\\)" #Xe161)
    ("\\(~>\\)" #Xe167) ("\\(~~>\\)" #Xe169)
    ("\\(-~\\)" #Xe118) ("\\(~-\\)"  #Xe165)

    ;; MISC
    ("\\(www\\)"                   #Xe100)
    ("\\(<!--\\)"                  #Xe151)
    ("\\([email protected]\\)"                    #Xe164)
    ("[^<]\\(~~\\)"                #Xe168)
    ("\\(\\?=\\)"                  #Xe127)
    ("[^=]\\(:=\\)"                #Xe10c)
    ("\\(/>\\)"                    #Xe12e)
    ("[^\\+<>]\\(\\+\\)[^\\+<>]"   #Xe16d)
    ("[^:=]\\(:\\)[^:=]"           #Xe16c)
    ("\\(<=\\)"                    #Xe157))
  "Fira font ligatures and their regexes.")

(if (fboundp 'mac-auto-operator-composition-mode)
    (mac-auto-operator-composition-mode)
  (pretty-fonts-set-kwds
   '((pretty-fonts-fira-font prog-mode-hook org-mode-hook))))

(straight-use-package '(point-history :type git :host github :repo "blue0513/point-history"))
(use-package point-history
  :ghook 'after-init-hook
  :bind (("C-c C-/" . point-history-show))
  :init (gsetq point-history-ignore-buffer "^ \\*Minibuf\\|^ \\*point-history-show*"))

(straight-use-package 'undo-propose)
(use-package undo-propose
  :defer
  :config (undo-propose-wrap redo))

(dolist (package '(git-blamed
                   git-timemachine))
  (straight-use-package package))

(straight-use-package 'git-modes)

(straight-use-package 'magit)
(use-package magit
  :defer t
  :commands magit-status
  :hook ((magit-popup-mode-hook . no-trailing-whitespace)
         (git-commit-mode . goto-address-mode))
  :init (gsetq magit-diff-refine-hunk t)
  :bind (([(meta f12)] . magit-status)  ;; Hint: customize `magit-repository-directories' so that you can use C-u M-F12 to
         ("C-x g"      . magit-status)
         ("C-x M-g"    . magit-dispatch-popup)
         :map magit-status-mode-map
         ("C-M-<up>"   . magit-section-up)
         :map vc-prefix-map
         ("f"          . vc-git-grep))
  :config
  (gsetq vc-handled-backends nil)
  (when *is-a-mac* (add-hook 'magit-mode-hook (lambda () (local-unset-key [(meta h)])))))

(straight-use-package 'magit-todos)
(use-package magit-todos
  :defer t
  :hook ((magit-status-mode . magit-todos-mode)))

(straight-use-package 'magit-org-todos)
(use-package magit-org-todos
  :defer t
  :config (magit-org-todos-autoinsert))

(straight-use-package 'forge)

(straight-use-package 'transient)
(use-package transient
  :init (gsetq transient-default-level 5))

(straight-use-package 'git-messenger)
(use-package git-messenger
  :init (gsetq git-messenger:show-detail t)
  :bind (:map vc-prefix-map
         ("p" . git-messenger:popup-message)))

(straight-use-package 'git-gutter)
(use-package git-gutter
  :diminish
  :hook (after-init . global-git-gutter-mode)
  :init (gsetq git-gutter:visual-line t
               git-gutter:disabled-modes '(asm-mode image-mode)
               git-gutter:modified-sign "❚"
               git-gutter:added-sign "✚"
               git-gutter:deleted-sign "✘")

  :config (general-define-key
           :prefix "C-x"
           "v =" 'git-gutter:popup-hunk
           "p"   'git-gutter:previous-hunk
           "n"   'git-gutter:next-hunk))

(straight-use-package 'gist)

(straight-use-package 'bing-dict)
(use-package bing-dict
  :bind (("C-c d" . bing-dict-brief))
  :init (gsetq bing-dict-show-thesaurus  'both
               bing-dict-vocabulary-save t
               bing-dict-cache-auto-save t
               bing-dict-vocabulary-file
               (no-littering-expand-var-file-name "bing-dict/vocabulary.org")
               bing-dict-cache-file
               (no-littering-expand-var-file-name "bing-dict/bing-dict-save.el")))

(use-package ispell
  :if *ispell*
  :init
  (gsetq-default ispell-program-name   *ispell*
                 ispell-silently-savep t
                 ispell-dictionary     "english"
                 ispell-personal-dictionary
                 (no-littering-expand-var-file-name "ispell/dictionary"))
  (when (string-suffix-p "aspell" *ispell*)
    (gsetq-default ispell-extra-args '("--reverse"))))

(unless *ispell*
  (message "if you want to use ispell, try\n brew install aspell\n brew install ispell"))

(straight-use-package 'lsp-mode)
(use-package lsp-mode
  :commands (lsp lsp-deferred)
  :preface
  (defun delete-company-lsp ()
    "Delete company-lsp added by lsp-mode from company-backends"
    (when 'company-backends
      (gsetq company-backends (delete 'company-lsp company-backends)
             company-backends (delete 'intero-company company-backends))))
  :hook ((lsp-after-open . lsp-enable-imenu)
         ((lsp-mode
           lsp-after-open
           prog-mode
           company-box-mode
           company-mode) . delete-company-lsp))
  :init (gsetq lsp-print-io                     t
               lsp-print-performance            t
               lsp-inhibit-message              t
               lsp-report-if-no-buffer          t
               lsp-keep-workspace-alive         nil
               lsp-enable-snippet               t
               lsp-restart                      'auto-restart
               lsp-document-sync-method         'full
               lsp-eldoc-render-all             t
               lsp-enable-completion-at-point   t
               lsp-enable-xref                  t
               lsp-enable-indentation           t
               lsp-prefer-flymake               nil
               lsp-enable-on-type-formatting    t
               lsp-enable-semantic-highlighting t))

(straight-use-package 'lsp-ui)
(use-package lsp-ui
  :commands lsp-ui-mode
  :bind (:map lsp-ui-mode-map
              ("M-,"  . lsp-ui-peek-find-definitions)
              ("M-?"  . lsp-ui-peek-find-references)
              ("C-c u"   . lsp-ui-imenu)
              ("C-c C-a" . lsp-ui-sideline-apply-code-actions))
  :ghook 'lsp-mode-hook
  :init
  (gsetq lsp-ui-doc-position 'at-point
         lsp-ui-doc-header nil
         lsp-ui-doc-border "violet"
         ;; lsp-ui-doc-include-signature t
         lsp-ui-sideline-update-mode 'point
         lsp-ui-sideline-delay 1
         lsp-ui-sideline-ignore-duplicate t
         lsp-ui-peek-always-show t
         lsp-ui-flycheck-enable t))

(straight-use-package 'company-lsp)
(use-package company-lsp
  :after company
  :defer t
  :commands company-lsp
  :init
  (with-eval-after-load 'company-mode
    (general-pushnew
     '(company-lsp
       company-files
       company-dabbrev-code
       company-gtags
       company-etags
       company-keywords
       :with company-yasnippet)
     company-backends))
  (gsetq company-lsp-async               t
         company-lsp-enable-recompletion t
         company-transformers            nil
         company-lsp-enable-snippet      t
         company-lsp-cache-candidates    nil)
  :config
  (setcdr (assq 'pyls company-lsp-filter-candidates) t))

(straight-use-package 'dap-mode)

(straight-use-package 'helm-lsp)
(use-package helm-lsp :commands helm-lsp-workspace-symbol)

(straight-use-package 'lsp-treemacs)
(use-package lsp-treemacs
  :commands lsp-treemacs-errors-list
  :config
  (lsp-metals-treeview-enable t)
  (gsetq lsp-metals-treeview-show-when-views-received t))

(use-package lsp-mode
  :if *clangd*
  :hook (((c-mode c++-mode objc-mode) . lsp-deferred))
  :init (setq-default lsp-clients-clangd-executable *clangd*))

(when *ccls*
  (straight-use-package 'ccls)
  (use-package ccls
    :preface
    (defun ccls/load ()
      (require 'ccls)
      (lsp-deferred))
    :hook (((c-mode c++-mode objc-mode) . ccls/load))
    :init (gsetq ccls-executable *ccls*
                 ccls-initialization-options
                 '(:clang (:extraArgs
                           ["-isysroot"
                            "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk"]))
                 ccls-sem-highlight-method 'font-lock)
    :config
    (ccls-use-default-rainbow-sem-highlight)
    (defun ccls/callee ()
      (interactive)
      (lsp-ui-peek-find-custom "$ccls/call" '(:callee t)))
    (defun ccls/caller ()
      (interactive)
      (lsp-ui-peek-find-custom "$ccls/call"))
    (defun ccls/vars (kind)
      (lsp-ui-peek-find-custom "$ccls/vars" `(:kind ,kind)))
    (defun ccls/base (levels)
      (lsp-ui-peek-find-custom "$ccls/inheritance" `(:levels ,levels)))
    (defun ccls/derived (levels)
      (lsp-ui-peek-find-custom "$ccls/inheritance" `(:levels ,levels :derived t)))
    (defun ccls/member (kind)
      (lsp-ui-peek-find-custom "$ccls/member" `(:kind ,kind)))

    ;; The meaning of :role corresponds to https://github.com/maskray/ccls/blob/master/src/symbol.h

    ;; References w/ Role::Address bit (e.g. variables explicitly being taken addresses)
    (defun ccls/references-address ()
      (interactive)
      (lsp-ui-peek-find-custom "textDocument/references"
       (plist-put (lsp--text-document-position-params) :role 128)))

    ;; References w/ Role::Dynamic bit (macro expansions)
    (defun ccls/references-macro ()
      (interactive)
      (lsp-ui-peek-find-custom "textDocument/references"
       (plist-put (lsp--text-document-position-params) :role 64)))

    ;; References w/o Role::Call bit (e.g. where functions are taken addresses)
    (defun ccls/references-not-call ()
      (interactive)
      (lsp-ui-peek-find-custom "textDocument/references"
       (plist-put (lsp--text-document-position-params) :excludeRole 32)))

    ;; References w/ Role::Read
    (defun ccls/references-read ()
      (interactive)
      (lsp-ui-peek-find-custom "textDocument/references"
       (plist-put (lsp--text-document-position-params) :role 8)))

    ;; References w/ Role::Write
    (defun ccls/references-write ()
      (interactive)
      (lsp-ui-peek-find-custom "textDocument/references"
       (plist-put (lsp--text-document-position-params) :role 16)))

    ;; xref-find-apropos (workspace/symbol)

    (defun my/highlight-pattern-in-text (pattern line)
      (when (> (length pattern) 0)
        (let ((i 0))
         (while (string-match pattern line i)
           (setq i (match-end 0))
           (add-face-text-property (match-beginning 0) (match-end 0) 'isearch t line))

         line)))

    (with-eval-after-load 'lsp-methods
      ;;; Override
      ;; This deviated from the original in that it highlights pattern appeared in symbol
      (defun lsp--symbol-information-to-xref (pattern symbol)
       "Return a `xref-item' from SYMBOL information."
       (let* ((location (gethash "location" symbol))
              (uri (gethash "uri" location))
              (range (gethash "range" location))
              (start (gethash "start" range))
              (name (gethash "name" symbol)))
         (xref-make (format "[%s] %s"
                            (alist-get (gethash "kind" symbol) lsp--symbol-kind)
                            (my/highlight-pattern-in-text (regexp-quote pattern) name))
                    (xref-make-file-location (string-remove-prefix "file://" uri)
                                             (1+ (gethash "line" start))
                                             (gethash "character" start)))))

      (cl-defmethod xref-backend-apropos ((_backend (eql xref-lsp)) pattern)
        (let ((symbols (lsp--send-request (lsp--make-request
                                           "workspace/symbol"
                                           `(:query ,pattern)))))
          (mapcar (lambda (x) (lsp--symbol-information-to-xref pattern x)) symbols))))))

(straight-use-package 'haskell-mode)
(use-package haskell-mode
  :preface
  (define-minor-mode stack-exec-path-mode
    "If this is a stack project, set `exec-path' to the path \"stack exec\" would use."
    nil
    :lighter ""
    :global nil
    (if stack-exec-path-mode
        (when (and (executable-find "stack")
                   (locate-dominating-file default-directory "stack.yaml"))
          (setq-local
           exec-path
           (seq-uniq
            (append (list (concat (string-trim-right (shell-command-to-string "stack path --local-install-root")) "/bin"))
                    (parse-colon-path
                     (replace-regexp-in-string "[\r\n]+\\'" ""
                                               (shell-command-to-string "stack path --bin-path"))))
            'string-equal)))
      (kill-local-variable 'exec-path)))

  :gfhook '(subword-mode
            haskell-auto-insert-module-template
            haskell-collapse-mode
            stack-exec-path-mode
            interactive-haskell-mode
            (lambda () (gsetq-local tab-width 4)))
  :bind (("C-x a a" . align)
         :map haskell-mode-map
         ("C-c h" . hoogle)
         ("C-o"   . open-line))
  :init
  (gsetq haskell-mode-stylish-haskell-path            "stylish-haskell"
         haskell-indentation-layout-offset            4
         haskell-indentation-left-offset              4
         haskell-process-suggest-haskell-docs-imports t
         haskell-process-suggest-remove-import-lines  t
         haskell-process-auto-import-loaded-modules   t
         haskell-process-log                          t
         haskell-process-suggest-hayoo-imports        t
         haskell-process-suggest-hoogle-imports       t
         haskell-process-suggest-remove-import-lines  t
         haskell-tags-on-save                         t
         haskell-completing-read-function             'helm--completing-read-default
         haskell-doc-show-global-types                t
         haskell-svg-render-images                    t
         haskell-doc-chop-off-context                 nil)

  (unless *struct-hs*
    (add-hook #'haskell-mode-hook #'haskell-indentation-mode))

  (unless (fboundp 'align-rules-list)
    (defvar align-rules-list nil))

  (add-to-list 'align-rules-list
               '(haskell-types
                 (regexp . "\\(\\s-+\\)\\(::\\|∷\\)\\s-+")
                 (modes quote (haskell-mode literate-haskell-mode))))
  (add-to-list 'align-rules-list
               '(haskell-assignment
                 (regexp . "\\(\\s-+\\)=\\s-+")
                 (modes quote (haskell-mode literate-haskell-mode))))
  (add-to-list 'align-rules-list
               '(haskell-arrows
                 (regexp . "\\(\\s-+\\)\\(->\\|→\\)\\s-+")
                 (modes quote (haskell-mode literate-haskell-mode))))
  (add-to-list 'align-rules-list
               '(haskell-left-arrows
                 (regexp . "\\(\\s-+\\)\\(<-\\|←\\)\\s-+")
                 (modes quote (haskell-mode literate-haskell-mode))))

  :config
  (push 'haskell-mode page-break-lines-modes)
  (defun haskell-mode-generate-tags (&optional and-then-find-this-tag)
    "Generate tags using Hasktags.  This is synchronous function.

  If optional AND-THEN-FIND-THIS-TAG argument is present it is used
  with function `xref-find-definitions' after new table was
  generated."
    (interactive)
    (let* ((dir (haskell-cabal--find-tags-dir))
           (command (haskell-cabal--compose-hasktags-command dir)))
      (if (not command)
          (error "Unable to compose hasktags command")
        ;; I disabled the noisy shell command output.
        ;; The original is (shell-command command)
        (call-process-shell-command command nil "*Shell Command Output*" t)
        (haskell-mode-message-line "Tags generated.")
        (when and-then-find-this-tag
          (let ((tags-file-name dir))
            (xref-find-definitions and-then-find-this-tag)))))))

(straight-use-package 'lsp-haskell)
(use-package lsp-haskell
  :preface
  (defun start-lsp-haskell ()
    (require 'lsp-haskell)
    (lsp-deferred))
  :hook ((haskell-mode   . start-lsp-haskell)
         (lsp-after-open . (lambda () (add-hook 'before-save-hook #'lsp-format-buffer nil t)))
         (haskell-mode   . delete-company-lsp))
  :init
  (gsetq lsp-haskell-process-path-hie "hie-wrapper")
  ;; You can set the lsp-haskell settings here
  ;; (lsp-haskell-set-hlint-on)                    ;; default on
  ;; (lsp-haskell-set-max-number-of-problems 100)  ;; default 100
  ;; (lsp-haskell-set-liquid-on)                   ;; default off
  ;; (lsp-haskell-set-completion-snippets-on)      ;; default on
  )

(when *intero*
  (straight-use-package 'intero)
  (use-package intero
    :hook ((haskell-mode . intero-mode))
    :config
    (define-key intero-mode-map (kbd "M-?") nil)
    (define-key intero-mode-map (kbd "C-c C-r") nil)))

(if *struct-hs*
    (progn
      (add-to-list 'load-path *struct-hs-path*)
      (require 'shm)
      (setq shm-program-name *struct-hs*)
      (add-hook #'haskell-mode-hook #'structured-haskell-mode))
  (progn
    (when *struct-hs*
      (message (concat "*NOTE* about structured-haskell-mode:\n"
                       "https://github.com/projectional-haskell/structured-haskell-mode\n"
                       "No structured-haskell-mode elisp find.\n"
                       "If you want to use it, \n"
                       "please install it and config its variables *struct-hs-path* in user-config.el\n")))))

(straight-use-package 'haskell-snippets)

(use-package lisp-mode
  :preface
  (defun eval-last-sexp-or-region (prefix)
    "Eval region from BEG to END if active, otherwise the last sexp."
    (interactive "P")
    (if (and (mark) (use-region-p))
        (eval-region (min (point) (mark)) (max (point) (mark)))
      (pp-eval-last-sexp prefix)))
  :bind (:map emacs-lisp-mode-map
         ("<remap> <eval-expression>" . pp-eval-expression)
         ("C-x C-e" . eval-last-sexp-or-region)))

(straight-use-package 'highlight-quoted)
(use-package highlight-quoted
  :defer t
  :hook ((emacs-lisp-mode . highlight-quoted-mode)))

(straight-use-package 'elisp-def)
(use-package elisp-def
  :defer t
  :hook (((emacs-lisp-mode ielm-mode) . elisp-def-mode)))

(straight-use-package 'python-mode)
(use-package python-mode
  :commands python-mode
  :mode ("\\.py\\'" . python-mode)
  :interpreter (("python"  . python-mode)
                ("python3" . python-mode))
  :preface
  ;; TODO: Need improve.
  (defun setq-after ()
    "setq after python mode."
    (when (projectile-file-exists-p "mypy.ini")
      (gsetq flycheck-python-mypy-ini "mypy.ini"
             flycheck-mypy.ini        "mypy.ini"))

    (when (projectile-file-exists-p "pylintrc")
      (gsetq flycheck-pylintrc "pylintrc")))

  (defcustom nasy*python-buffer "vterm"
    "Nasy Python Buffer"
    :group 'python-mode
    :type 'string)

  (defun nasy/python-send-buffer ()
    "Send current buffer to the running python process."
    (interactive)
    (let ((proc (get-buffer-process nasy*python-buffer)))
      (unless proc
        (error "No process found"))
      (save-buffer)
      (comint-simple-send proc
                          (concat "%run " (format "%s" (buffer-file-name))))
      (pop-to-buffer nasy*python-buffer)))

  (defun nasy/python-send-region (begin end)
    "Evaluate the code in region from BEGIN to END in the python repl.
if the region is unset, the current line will be used."
    (interactive "r")
    (unless (use-region-p)
      (setq begin (line-beginning-position)
            end (line-end-position)))
    (let* ((text (buffer-substring-no-properties begin end))
           (proc (get-buffer-process nasy*python-buffer)))
      (unless proc
        (error "No process found"))
      (comint-simple-send proc text)
      (display-buffer nasy*python-buffer)))

  (defun nasy/python-send-defun (&optional arg)
    "Send the current defun to inferior Python process.
When ARG is non-nil do not include decorators."
    (interactive (list current-prefix-arg t))
    (nasy:python-send-region
     (progn
       (end-of-line 1)
       (while (and (or (python-nav-beginning-of-defun)
                    (beginning-of-line 1))
                 (> (current-indentation) 0)))
       (when (not arg)
         (while (and (forward-line -1)
                   (looking-at (python-rx decorator))))
         (forward-line 1))
       (point-marker)
       (progn
         (or (python-nav-end-of-defun)
            (end-of-line 1))
         (point-marker)))))

  (defun nasy/python-switch-to-shell ()
    "Switch to inferior Python process buffer."
    (interactive "p")
    (let ((proc (get-buffer-process nasy:python-buffer)))
      (unless proc
        (error "No process found"))
      (pop-to-buffer nasy*python-buffer)))
  :gfhook '(lsp-deferred
            delete-company-lsp
            setq-after)
  :init
  (general-define-key
   :prefix "C-c"
   :keymaps 'python-mode-map
   "C-b" 'nasy/python-send-buffer
   "C-r" 'nasy/python-send-region
   "C-c" 'nasy/python-send-defun
   "C-z" 'nasy/python-switch-to-shell)
  (general-define-key
   :keymaps 'python-mode-map
   "<S-return>" 'nasy/python-send-region)
  (gsetq python-indent-offset                  4
         indent-tabs-mode                      nil
         python-indent-guess-indent-offset     nil
         python-shell-completion-native-enable nil
         python-shell-interpreter              "ipython3"
         python-shell-interpreter-args         "-i"
         py-ipython-command-args               "-i"
         py-python-command                     "python3"
         flycheck-python-pycompile-executable  "python3"
         flycheck-python-pylint-executable     "python3"
         python-mode-modeline-display          "Python"
         python-skeleton-autoinsert            t
         py-python-command                     "python3"
         py-python2-command                    "python2"
         py-python3-command                    "python3"
         py-ipython-command                    "ptipython"
         py-ipython2-command                   "ipython2"
         py-ipython3-command                   "ipython3"
         py-set-fill-column-p                  t
         py-shell-name                         nasy*python-buffer)

  ;; A list here https://github.com/palantir/python-language-server/blob/develop/vscode-client/package.json#L23-L230
  ;; I prefer pydocstyle and black, so disabled yapf, though, pydocstyle still cannot be abled.
  ;; pip install black pyls-black -U
  ;; The default line-length is 88 when using black, you can add a file named "pyproject.yaml" that contains
  ;; [tool.black]
  ;; line-length = 79
  (with-eval-after-load 'lsp-pyls
    (gsetq lsp-pyls-configuration-sources                          ["pydocstyle" "pycodestyle" "pyflakes" "pylint"]
           lsp-pyls-plugins-pydocstyle-enabled                     t
           lsp-pyls-plugins-yapf-enabled                           t
           lsp-pyls-plugins-jedi-definition-follow-imports         t
           lsp-pyls-plugins-jedi-definition-follow-builtin-imports t
           lsp-pyls-plugins-jedi-signature-help-enabled            t
           lsp-pyls-plugins-jedi-symbols-enabled                   t
           lsp-pyls-plugins-pyls_mypy-live-mode                    nil))
  :config
  (unless *blacken*
    (add-hook #'python-mode-hook
              #'(lambda () (add-hook #'before-save-hook #'lsp-format-buffer nil t)))))

;; Now you can use it in lsp.
;; NOTICE you have to config black though pyproject.toml.
(when *blacken*
  (straight-use-package 'blacken)
  (use-package blacken
    :hook ((python-mode . blacken-mode))))

(straight-use-package 'py-isort)
(use-package py-isort
  :hook ((before-save . py-isort-before-save)))

(straight-use-package 'python-docstring)
(use-package python-docstring
  :hook ((python-mode . python-docstring-mode)))

(straight-use-package 'sphinx-doc)
(use-package sphinx-doc
  :hook ((python-mode . sphinx-doc-mode)))

(straight-use-package 'pyimport)
(use-package pyimport
  :bind (:map python-mode-map
              ("C-c C-i" . pyimport-insert-missing)))

(straight-use-package 'emojify)
(use-package emojify
  :commands emojify-mode
  :hook ((after-init . global-emojify-mode))
  :init (gsetq emojify-emoji-styles '(unicode github)
               emojify-display-style 'unicode))

(straight-use-package 'all-the-icons)
(use-package all-the-icons
  :init (gsetq inhibit-compacting-font-caches t))

;; (use-package cnfonts
;;   :disabled t
;;   :straight t
;;   :init
;;   (gsetq cnfonts-directory (no-littering-expand-etc-file-name "cnfonts"))
;;   :hook ((after-init . cnfonts-enable))
;;   :config
;;   (defun nasy/set-symbol-fonts (fontsize-list)
;;     "Set symbol fonts with FONTSIZE-LIST."
;;     (let* ((fontname "Fira Code Symbol")
;;            (fontsize (nth 0 fontsize-list))
;;            (fontspec (font-spec :name fontname
;;                                 :size fontsize
;;                                 :weight 'normal
;;                                 :slant 'normal)))
;;       (if (cnfonts--fontspec-valid-p fontspec)
;;           (set-fontset-font t '(#Xe100 . #Xe16f) fontspec)
;;         (message "Font %S not exists！" fontname))))
;;   (defun nasy/set-symbol-extra-fonts (fontsize-list)
;;     "Set extra symbol fonts with FONTSIZE-LIST."
;;     (let* ((fontname "Arial")
;;            (fontsize (nth 0 fontsize-list))
;;            (fontspec (font-spec :name fontname
;;                                 :size fontsize
;;                                 :weight 'normal
;;                                 :slant 'normal)))
;;       (if (cnfonts--fontspec-valid-p fontspec)
;;           (set-fontset-font t '(#X1d400 . #X1d744) fontspec)
;;         (message "Font %S not exists！" fontname))))
;;   (add-hook #'cnfonts-set-font-finish-hook #'nasy/set-symbol-fonts)
;;   (add-hook #'cnfonts-set-font-finish-hook #'nasy/set-symbol-extra-fonts))

(defun nasy/set-font ()
  "Nasy set font"
  (interactive)
  (set-face-attribute
   'default nil
   :font (font-spec :name   *font*
                    :weight *font-weight*
                    :size   *font-size*))

  (when (display-graphic-p)
    (dolist (charset '(kana han symbol cjk-misc bopomofo))
      (set-fontset-font
       (frame-parameter nil 'font)
       charset
       (font-spec :name   *font-cjk*
                  :weight *font-weight-cjk*
                  :size   *font-size-cjk*)))))

(nasy/set-font)

(straight-use-package 'doom-themes)
(use-package doom-themes
  :init (gsetq doom-dracula-brighter-comments t
               doom-dracula-colorful-headers  t
               doom-dracula-comment-bg        t)
  :config
  (with-eval-after-load 'treemacs
    (doom-themes-treemacs-config))
  (doom-themes-visual-bell-config)
  (with-eval-after-load 'org
    (doom-themes-org-config)))

(straight-use-package 'darktooth-theme)
(use-package darktooth-theme
  :config
  (darktooth-modeline))

(straight-use-package 'soothe-theme)

(load-theme *theme* t)