(defconst config-org (locate-user-emacs-file "README.org"))
(defconst config-el (locate-user-emacs-file "config.el"))

(unless (file-exists-p config-el)
  (require 'org)
  (org-babel-tangle-file config-org config-el))

(load-file config-el)

(defun fk/tangle-config ()
  "Export code blocks from the literate config file
asynchronously."
  (interactive)
  ;; prevent emacs from killing until tangle-process finished
  (add-to-list 'kill-emacs-query-functions
               (lambda ()
                 (or (not (process-live-p (get-process "tangle-process")))
                     (y-or-n-p "\"fk/tangle-config\" is running; kill it? "))))
  ;; tangle config asynchronously
  (fk/async-process
   (format "emacs %s --batch --eval '(org-babel-tangle nil \"%s\")'" config-org config-el)
   "tangle-process"))

(add-hook 'org-mode-hook
          (lambda ()
            (if (equal buffer-file-truename config-org)
                (fk/add-local-hook 'after-save-hook 'fk/tangle-config))))

(defvar bootstrap-version)
(let ((bootstrap-file
       (locate-user-emacs-file "straight/repos/straight.el/bootstrap.el"))
      (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-check-for-modifications '(check-on-save find-when-checking))

(setq vc-follow-symlinks t)

(setq straight-vc-git-default-clone-depth 1)

(use-package org
  :straight (:type built-in))

;; Install `use-package'.
(straight-use-package 'use-package)

;; Install packages in `use-package' forms with `straight'. (not the built-in
;; package.el)
(setq straight-use-package-by-default t)

;; Key Chord functionality in use-package. (I do not use it anymore.)
;; (use-package use-package-chords
;;   :hook
;;   (dashboard-after-initialize . (lambda () (key-chord-mode 1))))

(use-package package-name
  :hook
  (x-mode . last)
  (x-mode . second)
  (x-mode . first))

(setq gc-cons-threshold most-positive-fixnum)

(defconst 1mb 1048576)
(defconst 20mb 20971520)
(defconst 30mb 31457280)
(defconst 50mb 52428800)

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

(defun fk/restore-garbage-collection ()
  (run-at-time 1 nil (lambda () (setq gc-cons-threshold 30mb))))

(add-hook 'emacs-startup-hook 'fk/restore-garbage-collection 100)
(add-hook 'minibuffer-setup-hook 'fk/defer-garbage-collection)
(add-hook 'minibuffer-exit-hook 'fk/restore-garbage-collection)

(setq read-process-output-max 1mb)  ;; lsp-mode's performance suggest

(defvar default-file-name-handler-alist file-name-handler-alist)
(setq file-name-handler-alist nil)

(add-hook 'emacs-startup-hook
          (lambda ()
            (setq file-name-handler-alist default-file-name-handler-alist)) 95)

;; In Emacs 27+, package initialization occurs before `user-init-file' is
;; loaded, but after `early-init-file'. straight.el handles package
;; initialization, so we must prevent Emacs from doing it early!
(setq package-enable-at-startup nil)
(advice-add 'package--ensure-init-file :override 'ignore)

;; Resizing the Emacs frame can be a terribly expensive part of changing the
;; font. By inhibiting this, we easily halve startup times with fonts that are
;; larger than the system default.
(setq frame-inhibit-implied-resize t)

(defmacro fk/measure-time (&rest body)
  "Measure the time it takes to evaluate BODY."
  `(let ((time (current-time)))
     ,@body
     (message "%s" (float-time (time-since time)))))

(defun fk/time-since-startup (&optional prefix)
  "Display the time that past since emacs startup. Add PREFIX if given at the
start of message for debug purposes."
  (interactive)
  (let* ((prefix (or prefix ""))
         (time (float-time (time-since before-init-time)))
         (str (format "%s%s seconds" prefix time)))
    (if (or (not (string-empty-p prefix))
            (called-interactively-p 'interactive))
        (message str)
      str)))

(defvar fk/time-last-check nil)
(defvar fk/time-threshold 0)
(setq fk/time-threshold 0.02)

(defun fk/time-since-last-check (&optional prefix)
  "Display the time that past since last check. Add PREFIX if given at the
start of message for debug purposes."
  (interactive)
  (let* ((prefix (or prefix ""))
         (time (float-time (time-since (or fk/time-last-check before-init-time))))
         (str (format "%s%s seconds" prefix time)))
    (setq fk/time-last-check (current-time))
    (if (or (not (string-empty-p prefix))
            (called-interactively-p 'interactive))
        (when (> time fk/time-threshold) (message "%s" str))
      str)))

(use-package no-littering
  :config
  (with-eval-after-load 'recentf
    (add-to-list 'recentf-exclude no-littering-var-directory)
    (add-to-list 'recentf-exclude no-littering-etc-directory))

  (setq auto-save-file-name-transforms  ; autosaved-file-name~
        `((".*" ,(no-littering-expand-var-file-name "auto-save/") t))
        custom-file (no-littering-expand-etc-file-name "custom.el"))

  (when (file-exists-p custom-file)
    ;; Load `custom-set-variables', not load whole `custom.el' with unwanted
    ;; `custom-set-faces'
    (with-current-buffer (find-file-noselect custom-file)
      (goto-char 0)
      (forward-sexp)
      (call-interactively 'eval-last-sexp)
      (kill-buffer)))

  (defconst fk/static-directory (locate-user-emacs-file "static/"))

  (defun fk/expand-static-file-name (file)
    "Expand filename FILE relative to `fk/static-directory'."
    (expand-file-name file fk/static-directory)))

(setq-default
 ring-bell-function 'ignore                    ; prevent beep sound.
 inhibit-startup-screen t                      ; TODO: maybe better on early-init or performance?
 initial-major-mode 'fundamental-mode          ; TODO: maybe better on early-init or performance?
 initial-scratch-message nil                   ; TODO: maybe better on early-init?
 create-lockfiles nil                          ; .#locked-file-name
 confirm-kill-processes nil                    ; exit emacs without asking to kill processes
 backup-by-copying t                           ; prevent linked files
 require-final-newline t                       ; always end files with newline
 delete-old-versions t                         ; don't ask to delete old backup files
 revert-without-query '(".*")                  ; `revert-buffer' without confirmation
 uniquify-buffer-name-style 'forward           ; non-unique buffer name display: unique-part/non-unique-filename
 fast-but-imprecise-scrolling t                ; supposed to make scrolling faster on hold
 window-resize-pixelwise t                     ; correctly resize windows by pixels (e.g. in split-window functions)
 native-comp-async-report-warnings-errors nil  ; disable annoying native-comp warnings
 ad-redefinition-action 'accept                ; disable annoying "ad-handle-definition: ‘some-function’ got redefined" warnings
 use-short-answers t                           ; e.g. `y-or-n-p' instead of `yes-or-no-p'
 help-enable-symbol-autoload t)                ; perform autoload if docs are missing from autoload objects.

(global-auto-revert-mode)

(save-place-mode)

(global-so-long-mode)

(bind-key* "M-r" 'repeat)

(defun fk/add-local-hook (hook function)
  "Add buffer-local hook."
  (add-hook hook function :local t))

(defun fk/async-process (command &optional name filter)
  "Start an async process by running the COMMAND string with bash. Return the
process object for it.

NAME is name for the process. Default is \"async-process\".

FILTER is function that runs after the process is finished, its args should be
\"(process output)\". Default is just messages the output."
  (make-process
   :command `("bash" "-c" ,command)
   :name (if name name
           "async-process")
   :filter (if filter filter
             (lambda (process output) (message (s-trim output))))))

;; Examples:
;;
;; (fk/async-process "ls")
;;
;; (fk/async-process "ls" "my ls process"
;;                   (lambda (process output) (message "Output:\n\n%s" output)))
;;
;; (fk/async-process "unknown command")

;; Make sure to focus when a new emacsclient frame created.
(add-hook 'server-after-make-frame-hook (lambda () (select-frame-set-input-focus (selected-frame))))

(defalias 'narrow-quit 'widen)  ; I forget `widen' everytime

;; TODO: lset would be useful too
(defmacro l (func &rest args)
  "Shorter lambda."
  `(lambda nil (apply ,func '(,@args))))

(defmacro li (func &rest args)
  "Shorter lambda, interactive."
  `(lambda nil (interactive) (apply ,func '(,@args))))

;; Examples:
;; (global-set-key (kbd "C-V") (lambda () (interactive) (next-line 10))) <-- Classical
;; (global-set-key (kbd "C-V") (li 'next-line 10)) <-- With li macro

(use-package helpful
  :custom
  ;; Use helpful in `helm-apropos'
  (helm-describe-function-function 'helpful-function)
  (helm-describe-variable-function 'helpful-variable)
  :bind
  (([remap describe-function] . helpful-callable)
   ([remap describe-variable] . helpful-variable)
   ([remap describe-key] . helpful-key)
   :map emacs-lisp-mode-map
   ("C-c C-d" . helpful-at-point)))

;; NOTE: I use F1 as C-h (paging & help).
(bind-keys*
 :prefix-map fk/menu-map
 :prefix "M-m"
 ("M-m" . which-key-show-major-mode)
 ("M-h" . help-command)
 ("M-u" . universal-argument)
 :map fk/menu-map :prefix-map buffers         :prefix "b"
 :map fk/menu-map :prefix-map comments        :prefix "c"
 :map fk/menu-map :prefix-map django          :prefix "d"
 :map fk/menu-map :prefix-map errors          :prefix "e"
 :map fk/menu-map :prefix-map files           :prefix "f"
 :map fk/menu-map :prefix-map org             :prefix "o"
 :map fk/menu-map :prefix-map text            :prefix "t"
 :map fk/menu-map :prefix-map version-control :prefix "v"
 :map fk/menu-map :prefix-map windows         :prefix "w")

(defun fk/straight-ignore-local-variables (orig-func &rest args)
  "Ignore local variables when visiting an installed package
which is generally not intended to be edited."
  (unless (string-prefix-p (straight--dir) default-directory)
    (apply orig-func args)))

(advice-add 'hack-local-variables-confirm :around 'fk/straight-ignore-local-variables)

(global-hl-line-mode)
(blink-cursor-mode -1)

(setq-default
 truncate-lines t
 frame-resize-pixelwise t             ; maximized emacs may not fit screen without this
 frame-title-format '("Emacs | %b"))  ; Emacs | buffer-name

(defun fk/disable-all-themes ()
  "Disable all active themes."
  (interactive)
  (dolist (theme custom-enabled-themes)
    (disable-theme theme)))

(defun fk/darken-background ()
  "Darken the background of the buffer."
  (interactive)
  (face-remap-add-relative 'default :background fk/dark-color))

(define-minor-mode fk/presentation-mode
  "A global minor mode for presentations. Make things easy to see."
  :global t
  (if fk/presentation-mode
      (progn
        (fk/adjust-font-size 40)
        (dimmer-mode 1)
        (setq zoom-size '(100 . 30))
        (zoom-mode 1)
        (setq default-window-divider-default-bottom-width window-divider-default-bottom-width
              default-window-divider-default-right-width window-divider-default-right-width)
        (setq window-divider-default-bottom-width 7
              window-divider-default-right-width 7)
        (window-divider-mode 1)
        (set-face-attribute 'olivetti-borders-face nil :background fk/darker-olivetti-borders-color)
        (olivetti-mode 1)
        (goggles-mode 1))
    (fk/adjust-font-size 0)
    (dimmer-mode -1)
    (setq zoom-size fk/zoom-default-size)
    (zoom-mode -1)
    (setq window-divider-default-bottom-width default-window-divider-default-bottom-width
          window-divider-default-right-width default-window-divider-default-right-width)
    (window-divider-mode 1)
    (set-face-attribute 'olivetti-borders-face nil :background fk/default-olivetti-borders-color)
    (olivetti-mode 1)
    (goggles-mode -1)))

(defun fk/toggle-ui-elements (&optional arg)
  "Toggle `display-line-numbers-mode', `highlight-indent-guides-mode' and
`display-fill-column-indicator-mode'."
  (interactive)
  (display-line-numbers-mode (or arg (if display-line-numbers-mode -1 1)))
  (highlight-indent-guides-mode (or arg (if highlight-indent-guides-mode -1 1)))
  (display-fill-column-indicator-mode (or arg (if display-fill-column-indicator-mode -1 1))))

(add-hook 'prog-mode-hook (lambda () (fk/toggle-ui-elements -1)) 100)

(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)
;; Do not show default modeline until doom-modeline is loaded
(setq-default mode-line-format nil)

(use-package good-scroll
  :straight (:host github :repo "io12/good-scroll.el")
  :commands good-scroll-mode
  :custom
  (good-scroll-duration 0.2)
  (good-scroll-point-jump 4)
  ;; :bind
  ;; ("C-v" . fk/smooth-scroll-up)
  ;; ("M-v" . fk/smooth-scroll-down)
  ;; ("C-l" . fk/smooth-recenter-top-bottom)
  ;; :hook
  ;; (dashboard-after-initialize . good-scroll-mode)
  :config
  (defun fk/smooth-scroll-down (&optional pixels)
    "Smooth alternative of M-v `scroll-down-command'."
    (interactive)
    (let ((good-scroll-step (or pixels 300)))
      (good-scroll-down)))

  (defun fk/smooth-scroll-up (&optional pixels)
    "Smooth alternative of C-v `scroll-up-command'."
    (interactive)
    (let ((good-scroll-step (or pixels 300)))
      (good-scroll-up)))

  (defun fk/smooth-recenter-top-bottom ()
    "docstring"
    (interactive)
    (let* ((current-row (cdr (nth 6 (posn-at-point))))
           (target-row (save-window-excursion
                         (recenter-top-bottom)
                         (cdr (nth 6 (posn-at-point)))))
           (distance-in-pixels (* (- target-row current-row) (line-pixel-height)))
           (good-scroll-step distance-in-pixels))
      (when (not (zerop distance-in-pixels))
        (good-scroll--update -1)))))

(setq window-divider-default-places t
      window-divider-default-bottom-width 1
      window-divider-default-right-width 1)

(window-divider-mode)

(defconst fk/default-font-family "RobotoMono Nerd Font")
(defconst fk/default-font-size 90)
(defconst fk/default-icon-size 15)

(defconst fk/variable-pitch-font-family "Noto Serif")

(custom-set-faces
 `(default ((t (:family ,fk/default-font-family :height ,fk/default-font-size))))
 `(variable-pitch ((t (:family ,fk/variable-pitch-font-family :height 1.0))))
 ;; Characters with fixed pitch face do not shown when height is 90.
 `(fixed-pitch-serif ((t (:height 1.2)))))

(defun fk/adjust-font-size (height)
  "Adjust font size by given height. If height is '0', reset font
size. This function also handles icons and modeline font sizes."
  (interactive "nHeight ('0' to reset): ")
  (let ((new-height (if (zerop height)
                        fk/default-font-size
                      (+ height (face-attribute 'default :height)))))
    (set-face-attribute 'default nil :height new-height)
    (set-face-attribute 'mode-line nil :height new-height)
    (set-face-attribute 'mode-line-inactive nil :height new-height)
    (message "Font size: %s" new-height))
  (let ((new-size (if (zerop height)
                      fk/default-icon-size
                    (+ (/ height 5) treemacs--icon-size))))
    (when (fboundp 'treemacs-resize-icons)
      (treemacs-resize-icons new-size))
    (when (fboundp 'company-box-icons-resize)
      (company-box-icons-resize new-size)))
  (when diff-hl-mode
    (diff-hl-maybe-redefine-bitmaps)))

(defun fk/increase-font-size ()
  "Increase font size by 0.5 (5 in height)."
  (interactive)
  (fk/adjust-font-size 5))

(defun fk/decrease-font-size ()
  "Decrease font size by 0.5 (5 in height)."
  (interactive)
  (fk/adjust-font-size -5))

(defun fk/reset-font-size ()
  "Reset font size according to the `fk/default-font-size'."
  (interactive)
  (fk/adjust-font-size 0))

(global-set-key (kbd "C-=") 'fk/increase-font-size)
(global-set-key (kbd "C--") 'fk/decrease-font-size)
(global-set-key (kbd "C-0") 'fk/reset-font-size)

(use-package doom-themes
  :custom-face
  (font-lock-comment-face ((t (:slant italic))))
  (font-lock-string-face ((t (:foreground "PeachPuff3"))))
  (font-lock-function-name-face ((t (:foreground "LightGoldenrod"))))
  (highlight ((t (:underline t :background nil :foreground nil))))
  (lazy-highlight ((t (:background nil :foreground nil :box (:line-width -1)))))
  (fixed-pitch ((t (:family "Noto Sans Mono"))))
  :config
  (load-theme 'doom-spacegrey t)
  (defconst fk/cursor-color (if (daemonp) "#D08770" (face-background 'cursor)))
  (defconst fk/font-color (if (daemonp) "#C0C5CE" (face-foreground 'default)))
  (defconst fk/background-color (if (daemonp) "#2B303B" (face-background 'default)))
  (defconst fk/dark-color (doom-darken fk/background-color 0.15))
  (defconst fk/dark-color1 (doom-darken fk/background-color 0.01))
  (defconst fk/dark-color2 (doom-darken fk/background-color 0.02))
  (defconst fk/dark-color3 (doom-darken fk/background-color 0.03))
  (defconst fk/dark-color4 (doom-darken fk/background-color 0.04))
  (defconst fk/dark-color5 (doom-darken fk/background-color 0.05))
  (defconst fk/dark-color6 (doom-darken fk/background-color 0.06))
  (defconst fk/dark-color7 (doom-darken fk/background-color 0.07))
  (defconst fk/dark-color8 (doom-darken fk/background-color 0.08))
  (defconst fk/dark-color9 (doom-darken fk/background-color 0.09))
  (defconst fk/light-color (doom-lighten fk/background-color 0.15))
  (defconst fk/light-color1 (doom-lighten fk/background-color 0.09))
  (defconst fk/light-color2 (doom-lighten fk/background-color 0.08))
  (defconst fk/light-color3 (doom-lighten fk/background-color 0.07))
  (defconst fk/light-color4 (doom-lighten fk/background-color 0.06))
  (defconst fk/light-color5 (doom-lighten fk/background-color 0.05))
  (defconst fk/light-color6 (doom-lighten fk/background-color 0.04))
  (defconst fk/light-color7 (doom-lighten fk/background-color 0.03))
  (defconst fk/light-color8 (doom-lighten fk/background-color 0.02))
  (defconst fk/light-color9 (doom-lighten fk/background-color 0.01)))

(defadvice load-theme (before disable-themes-first activate)
  (fk/disable-all-themes))

(advice-add 'load-theme
            :around
            (lambda (fn theme &optional no-confirm no-enable)
              (funcall fn theme t)))

(use-package poet-theme
  :defer t)

(use-package doom-modeline
  :init
  ;; show doom-modeline at the same time with dashboard
  (add-hook 'emacs-startup-hook 'doom-modeline-mode -100)
  :custom
  (doom-modeline-buffer-encoding nil)
  (doom-modeline-vcs-max-length 40)
  (doom-modeline-bar-width 1)
  (doom-modeline-env-python-executable "python")
  :custom-face
  (mode-line ((t (:background ,fk/dark-color))))
  (mode-line-inactive ((t (:background ,fk/dark-color5))))
  (mode-line-highlight ((t (:inherit cursor :foreground "black"))))
  (doom-modeline-bar ((t (:background ,fk/dark-color))))
  (doom-modeline-buffer-path ((t (:inherit font-lock-comment-face :slant normal))))
  :hook
  (dashboard-after-initialize . column-number-mode))

(defvar fk/minibuffer-modeline--message nil)

(defun fk/minibuffer-modeline-update ()
  "Show global info in minibuffer instead of modeline."
  (let* ((pyvenv-icon (all-the-icons-icon-for-mode 'python-mode :height 0.9 :v-adjust 0.01))
         (pyvenv (when (and (featurep 'pyvenv) pyvenv-virtual-env-name)
                   (format "[%s %s]" pyvenv-icon pyvenv-virtual-env-name)))
         (perspectives (when (featurep 'perspective)
                         (string-join (let ((persp-show-modestring t))
                                        (persp-update-modestring)
                                        (persp-mode-line)))))
         (pomidor (when (and (featurep 'pomidor) pomidor-timer)
                    (format " [%s]"
                            (string-limit
                             (let* ((break (pomidor--break-duration (car (last pomidor-global-state))))
                                    (overwork (pomidor--overwork-duration (car (last pomidor-global-state))))
                                    (work (pomidor--work-duration (car (last pomidor-global-state)))))
                               (cond
                                (break (propertize (pomidor--format-duration break) 'face 'pomidor-break-face))
                                (overwork (propertize (pomidor--format-duration overwork) 'face 'pomidor-overwork-face))
                                (work (propertize (pomidor--format-duration work) 'face 'pomidor-work-face)))) 5))))
         (time (propertize (format-time-string " %H:%M %a %d/%m" (current-time)) 'face 'font-lock-comment-face))
         (info (string-join (list pyvenv perspectives pomidor time) " "))
         (message (if fk/minibuffer-modeline--message fk/minibuffer-modeline--message ""))
         (right-padding 2)
         (left-padding (make-string (max 0 (- (frame-width) (length message) (length info) right-padding)) ?\ )))
    (setq fk/minibuffer-modeline--message nil)
    (with-current-buffer " *Minibuf-0*"
      (erase-buffer)
      (insert message left-padding info))))

(add-hook 'post-command-hook 'fk/minibuffer-modeline-update)

(setq fk/minibuffer-modeline-timer (run-at-time nil 10 'fk/minibuffer-modeline-update))

;;; Advices to not lose minibuffer modeline info  ; FIXME: breaks when using isearch

;; (defun fk/minibuffer-modeline-message (func &rest args)
;;   "Show message and modeline info at the same time."
;;   (unless inhibit-message
;;     (setq fk/minibuffer-modeline--message (apply func args))
;;     (fk/minibuffer-modeline-update)
;;     fk/minibuffer-modeline--message))

;; (advice-add 'message :around 'fk/minibuffer-modeline-message)

(use-package anzu
  :hook
  (dashboard-after-initialize . global-anzu-mode))

(use-package page-break-lines
  :custom-face
  (page-break-lines ((t (:inherit font-lock-comment-face :foreground ,fk/light-color1 :width expanded))))
  :hook
  (dashboard-after-initialize . global-page-break-lines-mode)
  :config
  (add-to-list 'page-break-lines-modes 'c-mode)
  (defun fk/insert-page-break-line ()
    "Insert a page break line character ''."
    (interactive)
    (insert "")))

(global-set-key (kbd "C-,") 'quoted-insert)

(use-package hl-todo
  :custom
  ;; Better hl-todo colors, taken from spacemacs
  (hl-todo-keyword-faces '(("TODO" . "#dc752f")
                           ("NEXT" . "#dc752f")
                           ("THEM" . "#2d9574")
                           ("PROG" . "#4f97d7")
                           ("OKAY" . "#4f97d7")
                           ("DONT" . "#f2241f")
                           ("FAIL" . "#f2241f")
                           ("DONE" . "#86dc2f")
                           ("NOTE" . "#b1951d")
                           ("KLUDGE" . "#b1951d")
                           ("HACK" . "#b1951d")
                           ("TEMP" . "#b1951d")
                           ("QUESTION" . "#b1951d")
                           ("HOLD" . "#dc752f")
                           ("FIXME" . "#dc752f")
                           ("XXX+" . "#dc752f")))
  :hook
  (dashboard-after-initialize . global-hl-todo-mode))

(use-package beacon
  :custom
  ;; beacon-mode doesn't work properly with same color as cursor
  (beacon-color (doom-darken fk/cursor-color 0.001))
  ;; (beacon-blink-when-point-moves-vertically 10)
  (beacon-dont-blink-major-modes '(dashboard-mode minibuff))
  :config
  (defun fk/beacon-blink ()
    "`beacon-blink' with `beacon-dont-blink-major-modes' control."
    (interactive)
    (unless (seq-find 'derived-mode-p beacon-dont-blink-major-modes)
      (beacon-blink)))
  ;; `beacon-blink' manually instead of activating `beacon-mode' to not
  ;; calculate every time on post-command-hook if should beacon blink
  ;; TODO: create a global minor mode with this: `fk/manual-beacon-mode'
  (dolist (command '(other-window
                     winum-select-window-by-number
                     scroll-up-command
                     scroll-down-command
                     recenter-top-bottom
                     ;; fk/smooth-scroll-up
                     ;; fk/smooth-scroll-down
                     ;; fk/smooth-recenter-top-bottom
                     move-to-window-line-top-bottom
                     ace-select-window
                     ace-swap-window
                     aw-flip-window
                     avy-goto-word-or-subword-1
                     avy-pop-mark))
    (eval `(defadvice ,command (after blink activate)
             (fk/beacon-blink))))
  (dolist (hook '(find-file-hook
                  xref-after-jump-hook
                  xref-after-return-hook
                  persp-switch-hook))
    (add-hook hook 'fk/beacon-blink)))

;; Prerequisite for a few packages (e.g. treemacs, all-the-icons-dired)
;; "M-x all-the-icons-install-fonts" to install fonts at the first time.
(use-package all-the-icons)

(use-package highlight-indent-guides
  :custom
  (highlight-indent-guides-method 'character)
  (highlight-indent-guides-responsive 'top)
  (highlight-indent-guides-auto-enabled nil)
  :custom-face  ; NOTE: The character does not work with "RobotoMono Nerd Font"
  (highlight-indent-guides-character-face ((t (:family "Source Code Pro" :foreground ,fk/light-color7))))
  (highlight-indent-guides-top-character-face ((t (:family "Source Code Pro" :foreground ,fk/light-color5))))
  :hook
  (prog-mode . highlight-indent-guides-mode))

(use-package shackle
  :custom
  (shackle-default-size 0.4)
  (shackle-rules '(("\\`\\*helm.*?\\*\\'" :regexp t :align t)  ; I use helm-posframe now, this is unnecessary but i want to keep just in case
                   ("\\`\\*helpful.*?\\*\\'" :regexp t :align t)
                   ("\\`\\*Go Translate*?\\*\\'" :regexp t :align t)
                   (help-mode :align t :select t)
                   (org-agenda-mode :align t :select t)))
  :hook
  (dashboard-after-initialize . shackle-mode))

;; TODO: Add a function to set window width to fill column width
;; according to current major mode
(use-package zoom
  :commands zoom-mode
  :preface
  (defvar fk/zoom-default-size '(120 . 40))
  :custom
  (zoom-size fk/zoom-default-size)
  :bind*
  (("C-M-=" . fk/enlarge-window)
   ("C-M--" . fk/shrink-window)
   ("C-M-0" . balance-windows))
  :config
  ;; TODO: handle when zoom-mode active
  (defun fk/adjust-window-width (percentage)
    (if (and olivetti-mode (= (count-windows) 1))
        (if (> percentage 1.0) (olivetti-expand) (olivetti-shrink))
      (let* ((new-width (round (* (window-width) percentage)))
             (zoom-size (cons new-width (cdr zoom-size))))
        (if (> percentage 1.0)  ; TODO: fk/smooth-zoom do not shrink
            (fk/smooth-zoom)
          (zoom)))))

  (defun fk/enlarge-window ()
    (interactive)
    (fk/adjust-window-width 1.1))

  (defun fk/shrink-window ()
    (interactive)
    (fk/adjust-window-width 0.9))

  (defvar fk/smooth-zoom-steps 10)
  (defvar fk/smooth-zoom-period 0.01)

  (defun fk/floor (number)
    "Floor by absolute value."
    (if (< number 0)
        (ceiling number)
      (floor number)))

  (defun fk/smooth-zoom ()
    "Smooth (animated) version of `zoom'."
    (interactive)
    (cancel-function-timers 'fk/smooth-zoom--resize)
    (setq fk/smooth-zoom-sizes '())
    (setq fk/smooth-zoom-window (get-buffer-window))
    (let* ((current-size (cons (window-width) (window-height)))
           (desired-size zoom-size)
           (distances (cons (- (car desired-size) (car current-size))
                            (- (cdr desired-size) (cdr current-size))))
           (step-distance (cons (fk/floor (/ (car distances) (float fk/smooth-zoom-steps)))
                                (fk/floor (/ (cdr distances) (float fk/smooth-zoom-steps))))))
      (dotimes (i fk/smooth-zoom-steps)
        (let* ((zoom-size (if (< i (1- fk/smooth-zoom-steps))
                              (cons (+ (car step-distance) (car current-size))
                                    (+ (cdr step-distance) (cdr current-size)))
                            desired-size))
               (time (concat (number-to-string (round (* i fk/smooth-zoom-period 1000))) " millisec")))
          (setq current-size zoom-size)
          (add-to-list 'fk/smooth-zoom-sizes current-size t)
          (run-at-time time nil 'fk/smooth-zoom--resize)))))

  (defun fk/smooth-zoom--resize ()
    (with-selected-window fk/smooth-zoom-window
      (let ((zoom-size (pop fk/smooth-zoom-sizes)))
        (zoom--resize)))))

(use-package dashboard
  :custom
  ;; Source for logo: https://github.com/tecosaur/emacs-config/blob/master/config.org#splash-screen
  (dashboard-startup-banner (fk/expand-static-file-name "logos/emacs-e-medium.png"))
  ;; Do not show package count, it is meaningless because of lazy loading.
  (dashboard-banner-logo-title "Welcome to Emacs!                          \n")
  (dashboard-init-info (format "  Emacs started in %s\n\n" (fk/time-since-startup)))
  (dashboard-set-heading-icons t)
  (dashboard-set-file-icons t)
  (dashboard-center-content t)
  (dashboard-items '((agenda . 0)  ; I override the insert-agenda function
                     (todo-items . 0)  ; Custom section
                     (inbox-entries . 0)))  ; Custom section
  :custom-face
  (dashboard-heading ((t (:inherit font-lock-keyword-face :height 1.2))))
  (dashboard-items-face ((t (:weight normal))))
  (dashboard-banner-logo-title ((t (:family "AV Qest" :height 3.0 :weight bold :foreground "#8583C7"))))
  :hook
  (dashboard-mode . (lambda () (setq-local cursor-type nil)))
  :config
  (dashboard-setup-startup-hook)

  ;; Run the hooks even if dashboard initialization is skipped
  (when (> (length command-line-args) 1)
    (add-hook 'emacs-startup-hook (lambda () (run-hooks 'dashboard-after-initialize-hook))))

  (defun fk/home ()
    "Switch to home (dashboard) buffer."
    (interactive)
    (if (get-buffer dashboard-buffer-name)
        (switch-to-buffer dashboard-buffer-name)
      (dashboard-refresh-buffer)))

  (defun fk/dashboard-get-section (expression)
    "Get expression output from Emacs daemon. Faster than reading it
in normal way if required libraries are already loaded in
daemon."
    (let* ((output-buffer (generate-new-buffer "*dashboard-temp*"))
           (exit-status (call-process "emacsclient" nil output-buffer nil
                                      "--eval" expression)))
      (if (zerop exit-status)
          (let* ((output (with-current-buffer output-buffer
                           (buffer-substring-no-properties (point-min) (point-max))))
                 (clean-output (string-trim (string-replace "#<marker" "<marker" output)))
                 (propertized-output (car (read-from-string clean-output))))
            (kill-buffer output-buffer)
            propertized-output)
        "Emacs server (daemon) is not running, Section couldn't loaded.")))

  ;; TODO: convert these string codes to normal code, investigate how emacs-async do that
  (defun fk/dashboard-get-agenda ()
    "Get a copy of the agenda buffer from Emacs daemon."
    (fk/dashboard-get-section
     "(progn
        (setq org-agenda-span 2)
        (org-agenda-list)
        (read-only-mode -1)
        (goto-char (point-min))
        (kill-line)
        (buffer-string))"))

  (defun dashboard-insert-agenda (&rest _)
    "Insert a copy of org-agenda buffer."
    (dashboard-insert-heading "Agenda for today:")
    (insert (fk/dashboard-get-agenda)))

  (defun fk/dashboard-get-inbox-entries ()
    ;; TODO: appearance is not consistent, seems like there is some sort of caching
    "Get inbox entry list from Emacs daemon."
    (fk/dashboard-get-section
     "(let* ((file (expand-file-name \"inbox.org\" org-directory))
             (file-buffer (find-file-noselect file))
             (file-content (with-current-buffer file-buffer (buffer-string)))
             (temp-buffer (generate-new-buffer \"*dashboard-temp*\"))
             (bullet (propertize \"⁖\" 'face 'org-level-1)))
        (with-current-buffer temp-buffer
          (kill-buffer file-buffer)
          (org-mode)
          (insert file-content)
          (delete-non-matching-lines \"^*\" (point-min) (point-max))
          (string-replace \"*\" (format \"  %s\" bullet) (string-replace \"**\" (format \"   %s\" bullet) (buffer-string)))))"))

  (defun fk/dashboard-insert-inbox-entries (&rest _)
    "Insert inbox entries items."
    (insert (all-the-icons-octicon "pin" :height 1.2 :v-adjust 0.02 :face 'dashboard-heading)
            (propertize " Inbox Entries:\n" 'face 'dashboard-heading 'line-spacing 10)
            (fk/dashboard-get-inbox-entries)))

  (defun fk/dashboard-get-todo-items ()
    "Get high priority todo items from Emacs daemon."
    (fk/dashboard-get-section
     "(let* ((file (expand-file-name \"todos.org\" org-directory))
             (file-buffer (find-file-noselect file))
             (file-content (with-current-buffer file-buffer (buffer-string)))
             (temp-buffer (generate-new-buffer \"*dashboard-temp*\"))
             (bullet (propertize \"⁖\" 'face 'org-level-1)))
        (with-current-buffer temp-buffer
          (kill-buffer file-buffer)
          (org-mode)
          (insert file-content)
          (delete-matching-lines (regexp-quote \"[#B]\") (point-min) (point-max))
          (delete-matching-lines (regexp-quote \"[#C]\") (point-min) (point-max))
          (delete-non-matching-lines \"^*\" (point-min) (point-max))
          (string-replace \"*\" (format \"  %s\" bullet) (string-replace \"**\" (format \"   %s\" bullet) (buffer-string)))))"))

  (defun fk/dashboard-insert-todo-items (&rest _)
    "Insert high priority todo items."
    (insert (all-the-icons-octicon "checklist" :height 1.2 :v-adjust 0.02 :face 'dashboard-heading)
            (propertize " TODOs:\n" 'face 'dashboard-heading 'line-spacing 10)
            (fk/dashboard-get-todo-items)))

  (add-to-list 'dashboard-item-generators  '(inbox-entries . fk/dashboard-insert-inbox-entries))
  (add-to-list 'dashboard-item-generators  '(todo-items . fk/dashboard-insert-todo-items))

  ;; Colorize org entries even if org.el or org-agenda.el hasn't loaded.
  ;; Note: defining faces is enough, color values comes from propertized string
  (defmacro fk/defface-nil (&rest faces)
    "Macro for defining nil faces. Instead of:
`(defface org-level-1 nil nil)'"
    `(progn ,@(cl-loop for face in faces
                       collect `(defface ,face nil nil))))
  (fk/defface-nil
   org-agenda-calendar-event
   org-agenda-current-time
   org-agenda-date
   org-agenda-date-today
   org-agenda-date-weekend
   org-agenda-date-weekend
   org-agenda-date-weekend-today
   org-agenda-structure
   org-checkbox-statistics-todo
   org-habit-alert-face
   org-habit-clear-future-face
   org-habit-overdue-future-face
   org-habit-ready-face
   org-hide
   org-imminent-deadline
   org-level-1
   org-level-2
   org-link
   org-scheduled
   org-scheduled-today
   org-super-agenda-header
   org-tag
   org-time-grid
   org-upcoming-deadline
   org-upcoming-distant-deadline
   org-warning))

(use-package stripe-buffer
  :custom-face
  (stripe-highlight ((t (:background ,fk/light-color7))))
  :config
  ;; hl-line (higher priority stripes) fix:
  (defadvice sb/redraw-region (after stripe-set-priority activate)
    (when (or stripe-buffer-mode stripe-table-mode)
      (dolist (overlay sb/overlays)
        (overlay-put overlay 'priority -100))))
  :hook
  (org-mode . turn-on-stripe-table-mode))

(use-package display-fill-column-indicator
  :straight (:type built-in)
  :custom
  (display-fill-column-indicator-character ?│)
  :custom-face  ; NOTE: The character above does not work with "Roboto Mono"
  (fill-column-indicator ((t (:family "Source Code Pro" :foreground ,fk/light-color7))))
  :hook
  (prog-mode . display-fill-column-indicator-mode))

(use-package display-line-numbers
  :straight (:type built-in)
  :custom-face
  (line-number ((t (:foreground ,fk/light-color2))))
  (line-number-current-line ((t (:foreground ,fk/light-color))))
  :hook
  (prog-mode . display-line-numbers-mode))

(use-package olivetti
  :straight (:host github :repo "KaratasFurkan/olivetti")
  :preface
  ;; Body width
  (setq fk/olivetti-body-width-default 120)
  (setq fk/olivetti-body-width-large 180)
  (setq olivetti-body-width fk/olivetti-body-width-default)
  ;; Borders
  (setq olivetti-enable-borders t)
  (setq fk/default-olivetti-borders-color fk/dark-color2)
  (setq fk/darker-olivetti-borders-color fk/dark-color9)
  :custom
  (olivetti-enable-visual-line-mode nil)
  (olivetti-window-local t)
  :custom-face
  (olivetti-borders-face ((t (:background ,fk/default-olivetti-borders-color))))
  :bind*
  (("C-1" . fk/smart-C-x-1)
   :map windows
   ("c" . olivetti-mode)
   :map windows
   :prefix-map olivetti
   :prefix "o"
   ("o" . global-olivetti-mode)
   ("e" . olivetti-expand)
   ("s" . olivetti-shrink))
  :hook
  (dashboard-after-initialize . global-olivetti-mode)
  :config
  (setq olivetti-excluded-buffer-regexps
        `(,@olivetti-excluded-buffer-regexps
          "\\`\\*vterm" "*fireplace*"))

  (defun fk/smart-C-x-1 ()
    (interactive)
    (if (= (count-windows) 1)
        (if (and global-olivetti-mode
                 (= olivetti-body-width fk/olivetti-body-width-default))
            (progn
              (setq olivetti-body-width fk/olivetti-body-width-large)
              (olivetti-mode))
          (call-interactively 'global-olivetti-mode)
          (setq olivetti-body-width fk/olivetti-body-width-default))
      (delete-other-windows))))

(use-package tree-sitter
  :commands fk/tree-sitter-hl-mode
  :config
  (defun fk/tree-sitter-hl-mode ()
    "Require `tree-sitter-langs' + Activate `tree-sitter-hl-mode'."
    (interactive)
    (require 'tree-sitter-langs)
    (call-interactively 'tree-sitter-hl-mode))

  (with-eval-after-load 'expand-region
    (defun tree-sitter-mark-bigger-node ()
      (interactive)
      (let* ((p (point))
             (m (or (mark) p))
             (beg (min p m))
             (end (max p m))
             (root (ts-root-node tree-sitter-tree))
             (node (ts-get-descendant-for-position-range root beg end))
             (node-beg (ts-node-start-position node))
             (node-end (ts-node-end-position node)))
        ;; Node fits the region exactly. Try its parent node instead.
        (when (and (= beg node-beg) (= end node-end))
          (when-let ((node (ts-get-parent node)))
            (setq node-beg (ts-node-start-position node)
                  node-end (ts-node-end-position node))))
        (set-mark node-end)
        (goto-char node-beg)))

    (setq er/try-expand-list (append er/try-expand-list
                                     '(tree-sitter-mark-bigger-node)))))

(use-package tree-sitter-langs
  :defer t
  :config
  ;; Custom patterns to make it look like in old versions:
  ;; See: https://github.com/ubolonton/emacs-tree-sitter/issues/153
  (tree-sitter-hl-add-patterns 'python
    [(assignment left: (identifier) @variable)])

  (tree-sitter-hl-add-patterns 'python
    [(decorator (call (identifier) @function.special))]))

(use-package visual-fill-column
  :commands visual-fill-column-mode
  :bind
  ( :map windows
    ("v" . visual-fill-column-mode))
  :hook
  (visual-fill-column-mode . visual-line-mode))

(use-package goggles
  :straight (:host github :repo "minad/goggles")
  :commands goggles-mode
  :custom
  (goggles-pulse-delay 0.1))

(use-package hideshow
  :straight (:type built-in)
  :defer nil
  :custom
  (hs-isearch-open t)
  :bind
  ( :map hs-minor-mode-map
    ("TAB" . fk/hs-smart-tab)
    ("<tab>" . fk/hs-smart-tab)
    ("<backtab>" . hs-toggle-hiding))
  :config
  (defun fk/hs-smart-tab ()
    "Pretend like `hs-toggle-hiding' if point is on a hiding block."
    (interactive)
    (if (save-excursion
          (move-beginning-of-line 1)
          (hs-looking-at-block-start-p))
        (hs-show-block)
      (indent-for-tab-command)))

  (defun fk/hide-second-level-blocks ()
    "Hide second level blocks (mostly class methods in python) in
current buffer."
    (interactive)
    (hs-minor-mode)
    (save-excursion
      (goto-char (point-min))
      (hs-hide-level 2))))

(use-package topspace
  :bind
  ( :map windows
    ("m" . topspace-recenter-buffer)))

(use-package redacted
  :commands redacted-mode
  :hook
  (redacted-mode . (lambda () (read-only-mode (if redacted-mode 1 -1)))))

(use-package posframe
  :defer t
  :custom
  (setq posframe-mouse-banish '(0 . 5000)))  ; Bottom-left corner to prevent EAF stealing focus

(add-to-list 'completion-styles 'flex t)

(setq completion-ignore-case t)
(setq read-buffer-completion-ignore-case t)
(setq read-file-name-completion-ignore-case t)

(use-package which-key-posframe
  :custom
  (which-key-idle-delay 2)
  (which-key-idle-secondary-delay 0)
  (which-key-posframe-border-width 2)
  (which-key-posframe-parameters '((left-fringe . 5) (right-fringe . 5)))
  :custom-face
  (which-key-posframe ((t (:background ,fk/dark-color))))
  (which-key-posframe-border ((t (:background ,fk/light-color))))
  :hook
  (dashboard-after-initialize . which-key-posframe-mode)
  (dashboard-after-initialize . which-key-mode))

(use-package helm
  :custom
  (helm-M-x-always-save-history t)
  (helm-display-function 'pop-to-buffer)
  (savehist-additional-variables '(extended-command-history))
  (history-delete-duplicates t)
  (helm-command-prefix-key nil)
  ;; Just move the selected text to the top of kill-ring, do not insert the text
  (helm-kill-ring-actions '(("Copy marked" . (lambda (_str) (kill-new _str)))
                            ("Delete marked" . helm-kill-ring-action-delete)))
  :custom-face
  (helm-non-file-buffer ((t (:inherit font-lock-comment-face))))
  (helm-ff-file-extension ((t (:inherit default))))
  (helm-buffer-file ((t (:inherit default))))
  :bind
  (("M-x" . helm-M-x)
   ("C-x C-f" . helm-find-files)
   ("C-x C-b" . helm-buffers-list)
   ("C-x b" . helm-buffers-list)
   ("C-x C-r" . helm-recentf)
   ("C-x C-i" . fk/helm-imenu)
   ("C-x C-j" . fk/helm-imenu)
   ("M-y" . fk/yank-pop-or-helm-show-kill-ring)
   :map helm-map
   ("TAB" . helm-execute-persistent-action)
   ("<tab>" . helm-execute-persistent-action)
   ("C-z" . helm-select-action)
   ("C-w" . backward-kill-word)  ; Fix C-w
   :map files
   ("f" . helm-find-files)
   ("r" . helm-recentf)
   ("b" . helm-bookmarks)
   :map buffers
   ("b" . helm-buffers-list)
   :map help-map
   ("a" . helm-apropos))
  :hook
  (dashboard-after-initialize . helm-mode)
  (helm-mode . savehist-mode)
  (helm-major-mode . fk/darken-background)
  :config
  (with-eval-after-load 'helm-buffers
    (dolist (regexp '("\\*epc con" "\\*helm" "\\*EGLOT" "\\*straight" "\\*Flymake"
                      "\\*eldoc" "\\*Compile-Log" "\\*xref" "\\*company"
                      "\\*aw-posframe" "\\*Warnings" "\\*Backtrace" "\\*helpful"
                      "\\*Messages" "\\*dashboard"))
      (add-to-list 'helm-boring-buffer-regexp-list regexp))
    (bind-keys
     :map helm-buffer-map
     ("M-d" . helm-buffer-run-kill-buffers)
     ("C-M-d" . helm-buffer-run-kill-persistent)))

  ;; "Waiting for process to die...done" fix.
  ;; Source: https://github.com/bbatsov/helm-projectile/issues/136#issuecomment-688444955
  (defun fk/helm--collect-matches (orig-fun src-list &rest args)
    (let ((matches
           (cl-loop for src in src-list
                    collect (helm-compute-matches src))))
      (unless (eq matches t) matches)))

  (advice-add 'helm--collect-matches :around 'fk/helm--collect-matches)

  (require 'helm-imenu)  ; Fixes buggy helm-imenu at first usage

  (defun fk/helm-imenu ()
    "helm-imenu without initializion (preselect)."
    (interactive)
    (unless helm-source-imenu
      (setq helm-source-imenu
            (helm-make-source "Imenu" 'helm-imenu-source
              :fuzzy-match helm-imenu-fuzzy-match)))
    (let* ((imenu-auto-rescan t)
           (helm-highlight-matches-around-point-max-lines 'never))
      (helm :sources 'helm-source-imenu
            :default ""
            :preselect ""
            :buffer "*helm imenu*")))

  (add-hook 'imenu-after-jump-hook (lambda ()
                                     (when (derived-mode-p 'outline-mode)
                                       (show-subtree))))

  (defun fk/yank-pop-or-helm-show-kill-ring ()
    "If called after a yank, call `yank-pop'. Otherwise, call
`helm-show-kill-ring'."
    (interactive)
    (if (eq last-command 'yank)
        (if (eq major-mode 'vterm-mode)
            (vterm-yank-pop)
          (yank-pop))
      (helm-show-kill-ring))))

(use-package helm-descbinds
  :commands helm-descbinds)

(use-package helm-posframe
  :straight (:host github :repo "KaratasFurkan/helm-posframe")
  :after helm
  :custom
  (helm-display-header-line nil)
  (helm-echo-input-in-header-line t)
  (helm-posframe-border-width 2)
  (helm-posframe-border-color fk/light-color)
  (helm-posframe-parameters '((left-fringe . 5) (right-fringe . 5)))
  (helm-posframe-size-function 'fk/helm-posframe-get-size)
  :config
  (helm-posframe-enable)
  ;; Remove annoying error message that displayed everytime after closing
  ;; helm-posframe. The message is:
  ;; Error during redisplay: (run-hook-with-args helm--delete-frame-function
  ;; #<frame 0x5586330a1f90>) signaled (user-error "No recursive edit is in
  ;; progress")
  (remove-hook 'delete-frame-functions 'helm--delete-frame-function)

  ;; Fix helm-posframe-display: Wrong type argument: window-live-p, #<window XYZ>
  (defun fk/helm-posframe-disable-on-minibuffer (orig-func &rest args)
    "Disable `helm-posframe' if it is called from minibuffer."
    (let ((helm-display-function 'helm-default-display-buffer))
      (apply orig-func args)))

  (advice-add 'helm-read-pattern-maybe :around 'fk/helm-posframe-disable-on-minibuffer)

  (defun fk/helm-posframe-get-size ()
    (list
     :min-width (or helm-posframe-min-width
                    (let ((half-frame-width (round (* (frame-width) 0.5)))
                          (three-quarter-frame-width (round (* (frame-width) 0.75))))
                      (if (> half-frame-width 100)
                          half-frame-width
                        three-quarter-frame-width)))
     :min-height (or helm-posframe-min-height
                     (let ((half-frame-height (round (* (frame-height) 0.5)))
                           (three-quarter-frame-height (round (* (frame-height) 0.75))))
                       (if (> half-frame-height 25)
                           half-frame-height
                         three-quarter-frame-height))))))

(use-package company
  :custom
  (company-idle-delay 0)
  (company-minimum-prefix-length 1)
  (company-tooltip-align-annotations t)
  (company-dabbrev-downcase nil)
  (company-dabbrev-other-buffers t) ; search buffers with the same major mode
  :bind
  ( :map company-active-map
    ("RET" . nil)
    ([return] . nil)
    ("C-w" . nil)
    ("TAB" . company-complete-selection)
    ("<tab>" . company-complete-selection)
    ("C-s" . company-complete-selection)  ; Mostly to use during yasnippet expansion
    ("C-n" . company-select-next)
    ("C-p" . company-select-previous))
  :hook
  (dashboard-after-initialize . global-company-mode)
  :config
  (add-to-list 'company-begin-commands 'backward-delete-char-untabify)

  ;; Show YASnippet snippets in company

  (defun fk/company-backend-with-yas (backend)
    "Add ':with company-yasnippet' to the given company backend."
    (if (and (listp backend) (member 'company-yasnippet backend))
        backend
      (append (if (consp backend)
                  backend
                (list backend))
              '(:with company-yasnippet))))

  (defun fk/company-smart-snippets (fn command &optional arg &rest _)
    "Do not show yasnippet candidates after dot."
    ;;Source:
    ;;https://www.reddit.com/r/emacs/comments/7dnbxl/how_to_temporally_filter_companymode_candidates/
    (unless (when (and (equal command 'prefix) (> (point) 0))
              (let* ((prefix (company-grab-symbol))
                     (point-before-prefix (if (> (- (point) (length prefix) 1) 0)
                                              (- (point) (length prefix) 1)
                                            1))
                     (char (buffer-substring-no-properties point-before-prefix (1+ point-before-prefix))))
                (string= char ".")))
      (funcall fn command arg)))

  ;; TODO: maybe show snippets at first?
  (defun fk/company-enable-snippets ()
    "Enable snippet suggestions in company by adding ':with
company-yasnippet' to all company backends."
    (interactive)
    (setq company-backends (mapcar 'fk/company-backend-with-yas company-backends))
    (advice-add 'company-yasnippet :around 'fk/company-smart-snippets))

  (fk/company-enable-snippets))

(use-package company-box
  :disabled
  :straight (:host github :repo "KaratasFurkan/company-box" :branch "consider-icon-right-margin-for-frame")
  :custom
  ;; Disable `single-candidate' and `echo-area' frontends
  (company-frontends '(company-box-frontend))
  (company-box-show-single-candidate t)
  ;;(company-box-frame-behavior 'point)
  (company-box-icon-right-margin 0.5)
  (company-box-backends-colors '((company-yasnippet . (:annotation default))))
  ;;:hook
  ;;(company-mode . company-box-mode)
  )

(use-package company-posframe
  :hook
  (company-mode . company-posframe-mode))

(use-package prescient
  :hook (dashboard-after-initialize . prescient-persist-mode))

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

;; It turns out company-prescient could not be disabled locally, lets go back to
;; company-statistics
;; (use-package company-statistics
;;   :hook (global-company-mode . company-statistics-mode))

(use-package yasnippet
  ;; Expand snippets with `C-j', not with `TAB'. Use `TAB' to always
  ;; jump to next field, even when company window is active. If there
  ;; is need to complete company's selection, use `C-s'
  ;; (`company-complete-selection').
  :custom
  (yas-indent-line nil)
  (yas-inhibit-overlay-modification-protection t)
  :custom-face
  (yas-field-highlight-face ((t (:inherit region))))
  :bind*
  (("C-j" . yas-expand)
   :map yas-minor-mode-map
   ("TAB" . nil)
   ("<tab>" . nil)
   :map yas-keymap
   ("TAB" . (lambda () (interactive) (company-abort) (yas-next-field)))
   ("<tab>" . (lambda () (interactive) (company-abort) (yas-next-field))))
  :hook
  (dashboard-after-initialize . yas-global-mode)
  (snippet-mode . (lambda () (setq-local require-final-newline nil))))

(use-package hydra
  :defer t
  :init
  (setq hydra-hint-display-type 'posframe)
  (setq hydra-posframe-show-params
        `( :internal-border-width 2
           :internal-border-color ,fk/light-color
           :left-fringe 5
           :right-fringe 5
           :poshandler posframe-poshandler-frame-bottom-center)))

(global-subword-mode)  ; navigationInCamelCase

(setq-default
 recenter-positions '(middle 0.15 top 0.85 bottom)  ; C-l positions
 scroll-conservatively 101)                         ; Smooth scrolling

;; Scroll less than default
(defvar fk/default-scroll-lines 15)

(defun fk/scroll-up (orig-func &optional arg)
  "Scroll up `fk/default-scroll-lines' lines (probably less than default)."
  (apply orig-func (list (or arg fk/default-scroll-lines))))

(defun fk/scroll-down (orig-func &optional arg)
  "Scroll down `fk/default-scroll-lines' lines (probably less than default)."
  (apply orig-func (list (or arg fk/default-scroll-lines))))

(advice-add 'scroll-up :around 'fk/scroll-up)
(advice-add 'scroll-down :around 'fk/scroll-down)

(defun fk/find-config ()
  "Open config file."
  (interactive)
  (find-file config-org))

(defun fk/persp-switch-config ()
  "Open config file in a dedicated perspective."
  (interactive)
  (persp-switch "config")
  (fk/find-config))

(defun fk/scratch ()
  "Switch to scratch buffer."
  (interactive)
  (switch-to-buffer "*scratch*"))

(defun fk/messages ()
  "Switch to Messages buffer."
  (interactive)
  (switch-to-buffer "*Messages*"))

(defun fk/split-window-below-and-switch ()
  "Split the window below, then switch to the new window."
  (interactive)
  (split-window-below)
  (other-window 1))

(defun fk/split-window-right-and-switch ()
  "Split the window right, then switch to the new window."
  (interactive)
  (split-window-right)
  (other-window 1))

(defun fk/generate-random-elisp-scratch ()
  "Create and switch to a temporary scratch buffer with a random name and
`emacs-lisp-mode' activated."
  (interactive)
  (switch-to-buffer (make-temp-name "scratch-elisp-"))
  (emacs-lisp-mode))

(defun fk/generate-random-org-scratch ()
  "Create and switch to a temporary scratch buffer with a random name and
`org-mode' activated."
  (interactive)
  (switch-to-buffer (make-temp-name "scratch-org-"))
  (org-mode))

(defun fk/generate-random-text-scratch ()
  "Create and switch to a temporary scratch buffer with a random name and
`text-mode' activated."
  (interactive)
  (switch-to-buffer (make-temp-name "scratch-text-"))
  (text-mode))

(setq fk/rg-special-characters '("(" ")" "[" "{" "*"))

(defun fk/convert-string-to-rg-compatible (str)
  "Escape special characters defined in `fk/rg-special-characters' of STR."
  (seq-reduce (lambda (str char) (string-replace char (concat "\\" char) str))
              fk/rg-special-characters
              str))

(defun fk/get-selected-text ()
  "Return selected text if region is active, else nil."
  (when (region-active-p)
    (let ((text (buffer-substring-no-properties (region-beginning) (region-end))))
      (deactivate-mark) text)))

(defun fk/find-installed-packages ()
  "Quick way of opening the source code of an installed package."
  (interactive)
  (helm-find-files-1 (straight--repos-dir)))

(defun fk/switch-last-buffer ()
  "Switch to last buffer."
  (interactive)
  (switch-to-buffer (other-buffer (current-buffer) nil)))

(defun fk/switch-last-window ()
  (interactive)
  (when-let ((last-win (get-mru-window nil nil t)))
    (select-window last-win)))

(global-set-key (kbd "<F1>") 'help-command)
(bind-key* (kbd "M-h") 'help-command)
(bind-key* (kbd "M-h M-h") 'help-for-help)
(global-set-key (kbd "C-x c") 'fk/persp-switch-config)
(global-set-key (kbd "C-x C-k") 'kill-current-buffer)
(global-set-key (kbd "M-l") 'move-to-window-line-top-bottom)
(bind-key* "C-q" 'fk/switch-last-window)
(global-set-key (kbd "M-g M-g") (lambda ()
                                  (interactive)
                                  (require 'avy)
                                  (avy-push-mark)
                                  (goto-line 1)))

;; Split & Switch
;; I use `fk/smart-C-x-1' for (kbd "C-1"), see Appearance / Olivetti
(global-set-key (kbd "C-2") 'fk/split-window-below-and-switch)
(global-set-key (kbd "C-3") 'fk/split-window-right-and-switch)

(bind-keys*
 :map files
 ("c" . fk/find-config)
 ("C" . fk/persp-switch-config)
 ("p" . fk/find-installed-packages))

(bind-keys*
 :map buffers
 ("s" . fk/scratch)
 ("r" . fk/generate-random-elisp-scratch)
 ("o" . fk/generate-random-org-scratch)
 ("t" . fk/generate-random-text-scratch)
 ("h" . fk/home)
 ("m" . fk/messages))

;; (defmacro fk/define-scratch-command (name mode kbd)
;;   "Define a scratch generator command and keybinding with the given
;; major-mode. Usage:
;; (fk/define-scratch-command
;;  \"my-search\" global-map \"C-M-s\" \"*.el\" \"foo\")"
;;   `(progn
;;      (defun ,(intern (concat "fk/" name)) ()
;;        (interactive)
;;        (require 'helm-rg)
;;        (fk/helm-rg-dwim-with-glob (or ,glob "") ,query))
;;      (define-key ,keymap (kbd ,kbd) ',(intern (concat "fk/" name)))))

;; (defmacro fk/helm-rg-define-search-commands (&rest args)
;;   "Define multiple search command at once. Usage:
;; (fk/helm-rg-define-search-commands
;;  (\"my-search\" global-map \"C-M-s\" \"*.el\" \"foo\")
;;  (\"my-other-search\" global-map \"C-M-S\" \"*.el\" \"bar\"))"
;;   `(progn ,@(cl-loop for expr in args
;;                      collect `(fk/helm-rg-define-search-command ,@expr))))

;; (defun fk/generate-random-elisp-scratch ()
;;   "Create and switch to a temporary scratch buffer with a random name and
;; `emacs-lisp-mode' activated."
;;   (interactive)
;;   (switch-to-buffer (make-temp-name "scratch-elisp-"))
;;   (emacs-lisp-mode))

;; (fk/define-scratch-commands
;;  ("generate-elisp-scratch"  'emacs-lisp-mode "b")
;;  ("generate-org-scratch"    'org-mode        "o")
;;  ("generate-text-scratch"   'text-mode       "t")
;;  ("generate-python-scratch" 'python-mode     "p")
;;  ("generate-json-scratch"   'json-mode       "j")

(bind-keys*
 :map windows
 ("b" . balance-windows)
 ("d" . delete-window)
 ("k" . kill-buffer-and-window))

(use-package recentf
  ;; Use with `helm-recentf'
  :straight (:type built-in)
  :preface
  (setq recentf-max-saved-items 200)
  :custom
  (recentf-exclude `(,(straight--build-dir)
                     ,(locate-user-emacs-file "eln-cache/")
                     "/usr/share/emacs/"
                     "/usr/local/share/emacs/"
                     "emacs/src/"
                     ,(expand-file-name "~/.virtualenvs")
                     "/usr/lib/node_modules/"
                     "/tmp/")))

(use-package winner
  :straight (:type built-in)
  :bind
  (("M-u" . winner-undo)
   ;; ("M-u" . (lambda () (interactive) (condition-case nil
   ;;                                       (xref-pop-marker-stack)
   ;;                                     (error (winner-undo)))))
   ("M-U" . winner-redo)
   :map windows
   ("u" . winner-undo)
   ("r" . winner-redo))
  :config
  (winner-mode))

(use-package ace-window
  :straight (:host github :repo "KaratasFurkan/ace-window" :branch "feature/posframe")
  :custom
  (aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l))
  (aw-ignore-current t)
  (aw-dispatch-when-more-than 3)  ; TODO: does not work
  :custom-face
  (aw-leading-char-face ((t (:height 15.0 :foreground "orangered2"))))
  :bind
  (("M-o" . ace-window)
   :map windows
   ("w" . ace-window)
   ("D" . ace-delete-window)
   ("s" . ace-swap-window)
   ("l" . aw-flip-window))
  :config
  (ace-window-posframe-mode))

(use-package helm-icons
  :straight (:host github :repo "yyoncho/helm-icons")
  :after helm
  :config
  (treemacs-resize-icons fk/default-icon-size)
  (helm-icons-enable))

(use-package winum
  :bind*
  ("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)
  :hook
  (dashboard-after-initialize . winum-mode))

(use-package mwim
  :bind
  ("C-a" . mwim-beginning-of-code-or-line)
  ("C-e" . mwim-end-of-line-or-code)
  ;; NOTE: Functions below are built-in but I think they fit in this context
  ("M-a" . fk/backward-sexp)
  ("M-e" . fk/forward-sexp)
  :config
  (defun fk/forward-sexp (&optional N)
    "Call `forward-sexp', fallback `forward-char' on error."
    (interactive)
    (condition-case nil
        (forward-sexp N)
      (error (forward-char N))))

  (defun fk/backward-sexp ()
    "`fk/forward-sexp' with negative argument."
    (interactive)
    (fk/forward-sexp -1)))

(use-package helm-projectile
  :custom
  (helm-projectile-sources-list '(helm-source-projectile-buffers-list
                                  helm-source-projectile-recentf-list
                                  helm-source-projectile-files-list
                                  helm-source-projectile-projects))
  :bind
  ("C-x f" . helm-projectile)
  :hook
  (projectile-mode . helm-projectile-on)
  :config
  (defun fk/projectile-recentf-files-first-five (original-function)
    "Return a list of five recently visited files in a project."
    (let ((files (funcall original-function)))
      (if (> (length files) 5)
          (seq-subseq files 0 5)
        files)))
  (advice-add 'projectile-recentf-files :around 'fk/projectile-recentf-files-first-five))

(use-package helm-ag
  :custom
  (helm-ag-base-command
   "rg -S --no-heading --color=never --line-number --max-columns 400")
  :bind
  (("C-M-S-s" . fk/helm-ag-dwim)
   :map helm-ag-map
   ("C-o" . helm-ag--run-other-window-action))
  :config
  (defun fk/helm-ag-dwim (&optional query)
    "Smarter version of helm-ag.
- Search in project if in a project else search in default (current) directory.
- Start search with selected text if region is active or empty string.
- Escape special characters when searching with selected text."
    (interactive)
    (let ((root-dir (or (projectile-project-root) default-directory))
          (query (or (fk/get-selected-text) query)))
      (helm-do-ag root-dir nil query)))

  (defun fk/helm-ag-dwim-with-glob (glob &optional query)
    (interactive)
    (let ((helm-ag-base-command (concat helm-ag-base-command " --glob " glob)))
      (fk/helm-ag-dwim query)))

  (defun fk/helm-ag--parse-options-and-query (func input)
    "Make `helm-ag' input ripgrep compatible."
    (apply func (list (fk/convert-string-to-rg-compatible input))))

  (advice-add 'helm-ag--parse-options-and-query :around 'fk/helm-ag--parse-options-and-query))

(use-package helm-rg
  :init
  ;; Load this macro even if helm-rg is not loaded yet
  (defmacro fk/helm-rg-define-search-command (name keymap kbd &optional glob query)
    "Define search commands and keybindings with predefined glob and query. Usage:
(fk/helm-rg-define-search-command
 \"my-search\" global-map \"C-M-s\" \"*.el\" \"foo\")"
    `(progn
       (defun ,(intern (concat "fk/" name)) ()
         (interactive)
         (require 'helm-rg)
         (fk/helm-rg-dwim-with-glob (or ,glob "") ,query))
       (define-key ,keymap (kbd ,kbd) ',(intern (concat "fk/" name)))))

  (defmacro fk/helm-rg-define-search-commands (&rest args)
    "Define multiple search command at once. Usage:
(fk/helm-rg-define-search-commands
 (\"my-search\" global-map \"C-M-s\" \"*.el\" \"foo\")
 (\"my-other-search\" global-map \"C-M-S\" \"*.el\" \"bar\"))"
    `(progn ,@(cl-loop for expr in args
                       collect `(fk/helm-rg-define-search-command ,@expr))))
  :custom
  (helm-rg-default-extra-args '("--max-columns" "400"
                                "-g" "!{*.min.css,*.min.js,*.svg,*.po}"
                                "-g" "!migrations/"))
  :custom-face
  (helm-rg-file-match-face ((t (:foreground nil :inherit font-lock-type-face :weight bold :underline nil :slant italic))))
  (helm-rg-line-number-match-face ((t (:foreground nil :underline nil :inherit line-number))))
  :bind
  (("C-M-s" . fk/helm-rg-dwim)
   :map helm-rg-map
   ("C-c C-e" . fk/helm-rg-switch-helm-ag)
   ("C-c C-d" . fk/helm-rg-switch-deadgrep))
  :config
  (defun fk/helm-rg-dwim (&optional query)
    "Smarter version of helm-rg.
- Search in project if in a project else search in default (current) directory.
- Start search with selected text if region is active or empty string.
- Escape special characters when searching with selected text."
    (interactive)
    (let ((helm-rg-default-directory (or (projectile-project-root) default-directory))
          (query (or (fk/get-selected-text) query)))
      (cl-letf (((symbol-function 'helm-rg--get-thing-at-pt) (lambda () query)))
        (call-interactively 'helm-rg))))

  (defun fk/helm-rg-dwim-with-glob (glob &optional query)
    (interactive)
    (let ((helm-rg-default-glob-string glob))
      (fk/helm-rg-dwim query)))


  ;;;; Input normalization

  (defvar fk/helm-rg-fuzzy-max-words 6)  ; rg returns "Arguments list too long" after this point

  (defun fk/helm-input-to-ripgrep-regexp (func input)
    "Make `helm-rg' input ripgrep compatible. Escape special
characters and disable fuzzy matching if input has more than
`fk/helm-rg-fuzzy-max-words' words."
    (let* ((processed-input (fk/convert-string-to-rg-compatible input))
           (word-count (with-temp-buffer
                         (insert processed-input)
                         (count-words (point-min) (point-max)))))
      (if (> word-count fk/helm-rg-fuzzy-max-words)
          (string-replace " " ".*" processed-input)  ; simpler fuzzy
        (apply func (list processed-input)))))

  (advice-add 'helm-rg--helm-pattern-to-ripgrep-regexp :around 'fk/helm-input-to-ripgrep-regexp)


  ;;;; Appearance

  ;; Use a simpler header in the helm buffer.
  (fset 'helm-rg--header-name
        (lambda (_)
          (format "Search at %s\nArgs: %s" helm-rg--current-dir (string-join helm-rg--extra-args " "))))

  ;; Create bigger window for helm-rg
  (advice-add 'helm-rg :around
              (lambda (orig-func &rest args)
                (let ((helm-posframe-min-height (round (* (frame-height) 0.66)))
                      (helm-candidate-number-limit 99999))  ; show all matching lines. TODO open a PR and make this default.
                  (apply orig-func args))))


  ;;;; Switch to another frontend functions

  (defun fk/helm-rg-switch-helm-ag ()
    "Switch to `helm-ag' to use its edit feature."
    (interactive)
    (helm-rg--run-after-exit
     (require 'helm-ag)
     (fk/helm-ag-dwim helm-pattern))
    (minibuffer-keyboard-quit))

  (defun fk/helm-rg-switch-deadgrep ()
    "Switch to `deadgrep' to use its seperated buffer and `before
n line' / `after n line' features."
    (interactive)
    (helm-rg--run-after-exit
     (require 'deadgrep)
     (deadgrep helm-pattern))
    (minibuffer-keyboard-quit)))

(use-package xref
  :custom
  (xref-prompt-for-identifier nil)
  :bind
  ("C-M-j" . xref-find-definitions)
  ("C-M-k" . xref-pop-marker-stack)
  ("C-9" . xref-find-definitions)
  ("C-8" . xref-pop-marker-stack)
  ("C-M-9" . xref-find-definitions-other-window)
  ("C-M-r" . xref-find-references))

(use-package helm-xref
  :after helm xref)

(use-package dumb-jump
  :custom
  (dumb-jump-aggressive t)
  :bind
  ([remap xref-find-definitions] . fk/smart-jump-go)
  ([remap xref-pop-marker-stack] . fk/smart-jump-back)
  ("C-M-S-j" . fk/smart-jump-peek)
  :config
  (defun fk/smart-jump-go ()
    "Fallback `dumb-jump-go' if `xref-find-definitions' cannot find the source."
    (interactive)
    (condition-case nil
        (call-interactively 'xref-find-definitions)
      (error (call-interactively 'dumb-jump-go))))

  (defun fk/smart-jump-back ()
    "Fallback `dumb-jump-back' if xref-pop-marker-stack cannot return back."
    (interactive)
    (if (string= (frame-parameter (selected-frame) 'name) "*Smart Jump Peek*")
        (progn (make-frame-invisible) (delete-frame))
      (condition-case nil
          (call-interactively 'xref-pop-marker-stack)
        (error (call-interactively 'dumb-jump-back)))))

  (defun fk/smart-jump-peek ()
    "`fk/smart-jump-go' in a new frame.
Source: http://tuhdo.github.io/emacs-frame-peek.html"
    (interactive)
    (let (summary
          doc-frame
          x y
          ;; 1. Find the absolute position of the current beginning of the symbol
          ;; at point, in pixels.
          (abs-pixel-pos (save-excursion
                           (beginning-of-thing 'symbol)
                           (window-absolute-pixel-position))))
      (setq x (car abs-pixel-pos))
      (setq y (+ (cdr abs-pixel-pos) (frame-char-height)))

      ;; 2. Create a new invisible frame, with the current buffer in it.
      (setq doc-frame (make-frame `((name . "*Smart Jump Peek*")
                                    (width . 100)
                                    (visibility . nil)
                                    (height . 20))))

      ;; 3. Position the new frame right under the beginning of the symbol at point.
      (set-frame-position doc-frame x y)

      ;; 4. Jump to the symbol at point.
      (with-selected-frame doc-frame
        (fk/smart-jump-go)
        (read-only-mode -1)
        (recenter-top-bottom 0))

      ;; 5. Make frame visible again
      (make-frame-visible doc-frame)
      (x-focus-frame doc-frame))))

(use-package helm-swoop
  :custom
  (helm-swoop-speed-or-color t)
  (helm-swoop-min-overlay-length 0)
  ;;(helm-swoop-use-fuzzy-match t)
  :custom-face
  (helm-swoop-target-line-face ((t (:background "black" :foreground nil :inverse-video nil :extend t))))
  (helm-swoop-target-word-face ((t (:inherit lazy-highlight :foreground nil))))
  :bind
  (("M-s" . helm-swoop)
   :map isearch-mode-map
   ("M-s" . helm-swoop-from-isearch)
   :map helm-swoop-map
   ("M-s" . helm-multi-swoop-all-from-helm-swoop)
   :map helm-swoop-edit-map
   ("C-c C-c" . helm-swoop--edit-complete)
   ("C-c C-k" . helm-swoop--edit-cancel))
  :config
  (with-eval-after-load 'shackle
    (setq helm-swoop-split-window-function 'display-buffer)))  ; shackle rules doesn't work without this

(use-package deadgrep
  :commands deadgrep
  :bind
  ( :map deadgrep-mode-map
    ("C-c C-e" . deadgrep-edit-mode)))

(use-package avy
  :custom
  (avy-dispatch-alist '((?c . avy-action-copy)
                        (?y . avy-action-yank)
                        (?t . avy-action-teleport)))
  :bind
  ("M-j" . avy-goto-word-or-subword-1)
  ("C-M-u" . avy-pop-mark)
  ("C-M-i" . (lambda () (interactive) (require 'avy) (avy-push-mark))))

(use-package treemacs
  :custom
  (treemacs-width 20)
  :bind
  ("M-0" . treemacs-select-window)
  :hook
  (treemacs-mode . (lambda ()
                     (face-remap-add-relative 'default :height .85)
                     (face-remap-add-relative 'mode-line-inactive :background fk/dark-color)
                     (face-remap-add-relative 'mode-line :background fk/dark-color)
                     (face-remap-add-relative 'hl-line :background fk/background-color :weight 'bold)
                     (fk/darken-background)))
  :config
  (treemacs-project-follow-mode))

(use-package treemacs-projectile
  :after treemacs projectile)

(use-package perspective
  :preface
  (defvar persp-icon (all-the-icons-material "dashboard" :height 0.9 :v-adjust -0.17 :face 'all-the-icons-blue))
  (defcustom persp-project-name nil "Should be set as directory local variable.")
  :custom
  (persp-mode-prefix-key (kbd "M-m p"))
  (persp-state-default-file (no-littering-expand-var-file-name "perspective.el"))
  (persp-modestring-dividers `(,(format "[%s " persp-icon) "]" " • "))
  (persp-show-modestring nil)  ; I show this in `fk/minibuffer-modeline-update' manually.
  :custom-face
  (persp-selected-face ((t (:foreground nil :inherit 'doom-modeline-warning))))
  :bind*
  ( :map persp-mode-map
    ("C-M-o" . persp-next)
    ("C-x p" . persp-switch)
    ("C-x C-p" . persp-switch-quick)
    ("M-q" . persp-switch-last)
    :map perspective-map
    ("p" . persp-switch)
    ("k" . persp-kill)
    ("l" . persp-switch-last)
    ("q" . persp-switch-quick)
    ("n" . (lambda () (interactive) (persp-switch (make-temp-name "p-"))))
    ("R" . fk/perspective-rename-with-project-name))
  :hook
  (dashboard-after-initialize . persp-mode)
  (kill-emacs . persp-state-save)
  :config
  (with-eval-after-load 'projectile
    (defun fk/perspective-rename-with-project-name ()
      "Rename current perspective according to current project name."
      (interactive)
      (when (projectile-project-p)
        (let* ((project-name (or persp-project-name (projectile-project-name)))
               (ellipsis "…")
               (short-name (if (> (length project-name) 10)
                               (concat (substring project-name 0 9) ellipsis)
                             project-name))
               (name (if (gethash short-name (perspectives-hash))
                         (concat "2—" short-name)
                       short-name)))
          (persp-rename name))))

    (define-minor-mode fk/perspective-auto-rename-mode
      "Rename perspectives according to project name automatically."
      :global t
      (if fk/perspective-auto-rename-mode
          (progn
            (ignore-errors (fk/perspective-rename-with-project-name))
            (add-hook 'projectile-after-switch-project-hook 'fk/perspective-rename-with-project-name))
        (remove-hook 'projectile-after-switch-project-hook 'fk/perspective-rename-with-project-name)))

    (fk/perspective-auto-rename-mode)))

(use-package block-nav
  :straight (:host github :repo "nixin72/block-nav.el")
  :config
  ;; TODO: DRY
  ;; (defun fk/block-nav-activate (file keymap)
  ;;   (with-eval-after-load file
  ;;     (define-key keymap (kbd "M-n") 'block-nav-next-block)
  ;;     (define-key keymap (kbd "M-p") 'block-nav-previous-block)))
  ;; (fk/block-nav-activate 'python 'python-mode-map)
  ;; (fk/block-nav-activate 'yaml-mode 'yaml-mode-map)
  ;; (fk/block-nav-activate 'docker-compose-mode 'docker-compose-mode-map)
  (with-eval-after-load 'python
    (define-key python-mode-map (kbd "M-n") 'block-nav-next-block)
    (define-key python-mode-map (kbd "M-p") 'block-nav-previous-block))
  (with-eval-after-load 'yaml-mode
    (define-key yaml-mode-map (kbd "M-n") 'block-nav-next-block)
    (define-key yaml-mode-map (kbd "M-p") 'block-nav-previous-block))
  (with-eval-after-load 'docker-compose-mode
    (define-key docker-compose-mode-map (kbd "M-n") 'block-nav-next-block)
    (define-key docker-compose-mode-map (kbd "M-p") 'block-nav-previous-block))
  (with-eval-after-load 'elisp-mode
    (define-key emacs-lisp-mode-map (kbd "M-n") 'block-nav-next-block)
    (define-key emacs-lisp-mode-map (kbd "M-p") 'block-nav-previous-block)))

(use-package goto-line-preview
  :commands goto-line-preview
  :bind
  ([remap goto-line] . goto-line-preview))

(use-package god-mode
  :preface
  (setq god-mode-cursor-color "#FFF8DC")
  :bind
  (("C-;" . god-mode-all)
   :map god-local-mode-map
   ("j" . avy-goto-word-or-subword-1))
  :hook
  (god-mode-enabled . (lambda ()
                        (set-face-attribute 'cursor nil :background god-mode-cursor-color)
                        ;; beacon-mode doesn't work properly with same color as cursor
                        (setq beacon-color (doom-darken god-mode-cursor-color 0.001))))
  (god-mode-disabled . (lambda ()
                         (set-face-attribute 'cursor nil :background fk/cursor-color)
                         ;; beacon-mode doesn't work properly with same color as cursor
                         (setq beacon-color (doom-darken fk/cursor-color 0.001)))))

(delete-selection-mode)
(electric-pair-mode)

(setq-default
 fill-column 80
 sentence-end-double-space nil
 indent-tabs-mode nil  ; Use spaces instead of tabs
 tab-width 4)

(defun fk/backward-kill-word-or-region ()
  "Calls `kill-region' when a region is active and `backward-kill-word'
otherwise."
  (interactive)
  (call-interactively (if (region-active-p)
                          'kill-region
                        'backward-kill-word)))

(defun fk/newline-below ()
  "Insert newline below the current line."
  (interactive)
  (save-excursion (end-of-line) (open-line 1)))

(defun fk/remove-hypens-and-underscores-region (beg end)
  "Remove hypens and underscores from region."
  (interactive "*r")
  (save-excursion
    (let* ((raw-str (buffer-substring-no-properties beg end))
           (clean-str (string-replace "_" " " (string-replace "-" " " raw-str))))
      (delete-region beg end)
      (insert clean-str))))

(defun fk/increment-number-at-point ()
  "Increment the number at point."
  (interactive)
  (when (number-at-point)
    (skip-chars-backward "0-9")
    (replace-match (number-to-string (1+ (string-to-number (match-string 0)))))))

(defun fk/decrement-number-at-point ()
  "Decrement the number at point."
  (interactive)
  (when (number-at-point)
    (skip-chars-backward "0-9")
    (replace-match (number-to-string (1- (string-to-number (match-string 0)))))))

(keyboard-translate ?\C-h ?\C-?)  ; C-h as DEL, (I use F1 and M-h as `help-command')
(add-hook 'server-after-make-frame-hook (lambda () (keyboard-translate ?\C-h ?\C-?)))  ; Fix emacs --daemon
(global-set-key (kbd "C-w") 'fk/backward-kill-word-or-region)
(global-set-key (kbd "C-o") 'fk/newline-below)
(global-set-key (kbd "C-x C-=") 'fk/increment-number-at-point)
(global-set-key (kbd "C-x C--") 'fk/decrement-number-at-point)

(bind-keys*
 :map text
 ("s" . sort-lines)
 ("r" . fk/remove-hypens-and-underscores-region))

(use-package undo-tree
  :custom
  (undo-tree-visualizer-diff t)
  (undo-tree-enable-undo-in-region t)
  :bind
  (("C-u" . undo-tree-undo)
   ("C-S-u" . undo-tree-redo))
  :hook
  (dashboard-after-initialize . global-undo-tree-mode))

(use-package whitespace-cleanup-mode
  :custom
  (show-trailing-whitespace t)  ; not from whitespace-cleanup-mode.el
  :custom-face
  (trailing-whitespace ((t (:background ,fk/light-color7))))  ; not from whitespace-cleanup-mode.el
  :hook
  (dashboard-after-initialize . global-whitespace-cleanup-mode)
  (after-change-major-mode . (lambda ()
                              (unless (buffer-file-name)
                                (setq-local show-trailing-whitespace nil)))))

(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)

;; built-in functions
(bind-keys
 :map text
 ("u" . upcase-dwim)
 ("d" . downcase-dwim)
 ("c" . capitalize-dwim))

(use-package string-inflection
  :bind
  ( :map text
    ("t" . string-inflection-all-cycle)
    ("k" . string-inflection-kebab-case)))

(use-package paren
  :straight (:type built-in)
  :custom
  (show-paren-when-point-inside-paren t)
  :custom-face
  (show-paren-match ((t (:background nil :weight bold :foreground "white"))))
  :hook
  (dashboard-after-initialize . show-paren-mode))

(use-package multiple-cursors
  :custom
  (mc/always-run-for-all t)
  :bind*
  (("C-M-n" . mc/mark-next-like-this)
   ("C-M-p" . mc/mark-previous-like-this)
   ("C-M-S-n" . mc/skip-to-next-like-this)
   ("C-M-S-p" . mc/skip-to-previous-like-this)
   ("C-S-n" . mc/unmark-previous-like-this)
   ("C-S-p" . mc/unmark-next-like-this)
   ("C-M-<mouse-1>" . mc/add-cursor-on-click)
   ("C-x C-n" . mc/insert-numbers)))

(use-package wrap-region
  :hook
  (dashboard-after-initialize . wrap-region-global-mode)
  :config
  (wrap-region-add-wrapper "=" "=" nil 'org-mode)
  (wrap-region-add-wrapper "*" "*" nil 'org-mode)
  (wrap-region-add-wrapper "_" "_" nil 'org-mode)
  (wrap-region-add-wrapper "/" "/" nil 'org-mode)
  (wrap-region-add-wrapper "+" "+" nil 'org-mode)
  (wrap-region-add-wrapper "~" "~" nil 'org-mode)
  (wrap-region-add-wrapper "#" "#" nil 'org-mode)
  (wrap-region-add-wrapper "`" "`" nil 'markdown-mode)
  (wrap-region-add-wrapper "`" "`" nil 'forge-post-mode)
  (wrap-region-add-wrapper "_(" ")" "_" 'python-mode)
  (wrap-region-add-wrapper "len(" ")" "l" 'python-mode))

(use-package unfill
  :bind
  ( :map text
    ("f" . unfill-toggle)))

(use-package expand-region
  :custom
  (expand-region-fast-keys-enabled nil)
  (expand-region-subword-enabled t)
  :bind*
  ("C-t" . er/expand-region))

(use-package flyspell-popup
  :after flyspell
  :custom
  (flyspell-popup-correct-delay 1)
  :config
  (flyspell-popup-auto-correct-mode))

(use-package company-wordfreq
  :straight (:host github :repo "johannes-mueller/company-wordfreq.el")
  :commands fk/company-wordfreq-mode
  :custom
  (company-wordfreq-path (concat no-littering-var-directory "wordfreq-dicts"))
  (ispell-local-dictionary "english")
  :config
  (define-minor-mode fk/company-wordfreq-mode
    "Suggest words by frequency."
    :global nil
    (if fk/company-wordfreq-mode
        (progn
          (setq-local company-backends-backup company-backends)
          (setq-local company-transformers-backup company-transformers)
          (setq-local company-backends '(company-wordfreq))
          (setq-local company-transformers nil))
      (setq-local company-backends company-backends-backup)
      (setq-local company-transformers company-transformers-backup)))

  (defun fk/company-wordfreq-toggle-language (&optional language)
    (interactive)
    (setq ispell-local-dictionary (or language
                                      (if (string= ispell-local-dictionary "english")
                                          "turkish"
                                        "english")))
    (message ispell-local-dictionary)))

(defun fk/align-comments (beginning end)
  "Align comments in region."
  (interactive "*r")
  (align-regexp beginning end (concat "\\(\\s-*\\)"
                                      (regexp-quote comment-start)) nil 2))

(defun fk/indent-buffer ()
  "Indent buffer."
  (interactive)
  (indent-region (point-min) (point-max)))

(defun fk/comment-or-uncomment-region ()
  "Comment or uncomment region with just a character (e.g. '/'). If a region is
active call comment-or-uncomment-region, otherwise just insert the given char."
  (interactive)
  (call-interactively (if (region-active-p)
                          'comment-or-uncomment-region
                        'self-insert-command)))

(use-package electric
  :straight (:type built-in)
  :bind
  ( :map prog-mode-map
    ("M-RET" . electric-indent-just-newline))
  :hook
  (dashboard-after-initialize . electric-indent-mode))

(use-package newcomment
  :straight (:type built-in)
  :custom
  (comment-column 0)
  (comment-inline-offset 2)
  :bind*
  ( :map comments
    ("c" . comment-dwim)
    ("k" . comment-kill)
    ("l" . comment-line)
    ("n" . (lambda () (interactive) (next-line) (comment-indent)))
    ("N" . comment-indent-new-line)
    ("b" . comment-box)
    ("a" . fk/align-comments))
  :hook
  (emacs-lisp-mode . (lambda ()
                       (setq-local comment-start "; ")
                       (setq-local comment-column 0))))

(use-package projectile
  :custom
  (projectile-auto-discover nil)
  (projectile-project-search-path (directory-files "~/projects" t "[^.]"))
  ;; Open magit when switching project
  (projectile-switch-project-action
   (lambda ()
     (let ((magit-display-buffer-function
            'magit-display-buffer-same-window-except-diff-v1))
       (magit))))
  ;; Ignore emacs project (source codes)
  (projectile-ignored-projects '("~/emacs/"))
  ;; Do not include straight repos (emacs packages) and emacs directory itself
  ;; to project list
  (projectile-ignored-project-function
   (lambda (project-root)
     (or (string-prefix-p (expand-file-name user-emacs-directory) project-root)
         (string-prefix-p "/usr/lib/node_modules/" project-root))))
  (projectile-kill-buffers-filter 'kill-only-files)
  :bind*
  ("C-M-t" . fk/projectile-vterm)
  :hook
  (dashboard-after-initialize . projectile-mode)
  :config
  (defun fk/projectile-vterm ()
    "Open `vterm' in project root directory."
    (interactive)
    (let* ((default-directory (or (projectile-project-root) default-directory))
           (project-name (projectile-project-name default-directory))
           (buffer-name (format "vterm @%s" project-name))
           (buffer (get-buffer buffer-name)))
      (if (or (not buffer) (eq buffer (current-buffer)))
          (vterm buffer-name)
        (switch-to-buffer buffer)))))

(use-package flycheck
  :custom
  (flycheck-check-syntax-automatically '(save mode-enabled))
  :bind
  ( :map errors
    ("n" . flycheck-next-error)
    ("p" . flycheck-previous-error)
    ("l" . flycheck-list-errors)
    ("v" . flycheck-verify-setup)))

;; Spacemacs' custom fringes

;; :config
;; (define-fringe-bitmap 'fk/flycheck-fringe-indicator
;;   (vector #b00000000
;;           #b00000000
;;           #b00000000
;;           #b00000000
;;           #b00000000
;;           #b00000000
;;           #b00000000
;;           #b00011100
;;           #b00111110
;;           #b00111110
;;           #b00111110
;;           #b00011100
;;           #b00000000
;;           #b00000000
;;           #b00000000
;;           #b00000000
;;           #b00000000))
;; (flycheck-define-error-level 'error
;;   :severity 2
;;   :overlay-category 'flycheck-error-overlay
;;   :fringe-bitmap 'fk/flycheck-fringe-indicator
;;   :error-list-face 'flycheck-error-list-error
;;   :fringe-face 'flycheck-fringe-error)
;; (flycheck-define-error-level 'warning
;;   :severity 1
;;   :overlay-category 'flycheck-warning-overlay
;;   :fringe-bitmap 'fk/flycheck-fringe-indicator
;;   :error-list-face 'flycheck-error-list-warning
;;   :fringe-face 'flycheck-fringe-warning)
;; (flycheck-define-error-level 'info
;;   :severity 0
;;   :overlay-category 'flycheck-info-overlay
;;   :fringe-bitmap 'fk/flycheck-fringe-indicator
;;   :error-list-face 'flycheck-error-list-info
;;   :fringe-face 'flycheck-fringe-info)

(use-package eglot
  :commands eglot
  :init
  (setq eglot-stay-out-of '(flymake))
  :custom
  (eglot-ignored-server-capabilites '(:documentHighlightProvider))
  (eglot-autoshutdown t)
  :hook
  ;; (eglot-managed-mode . eldoc-box-hover-mode)
  (eglot-managed-mode . fk/company-enable-snippets)
  :config
  (add-to-list 'eglot-server-programs '(python-mode . ("pyright-langserver" "--stdio")))
  (with-eval-after-load 'eglot
    (load-library "project")))

(use-package eldoc-box
  :commands (eldoc-box-hover-mode eldoc-box-hover-at-point-mode)
  :custom
  (eldoc-box-clear-with-C-g t))

(use-package lsp-mode
  :commands lsp
  :custom
  (lsp-auto-guess-root t)
  (lsp-keymap-prefix "M-m l")
  (lsp-modeline-diagnostics-enable nil)
  (lsp-keep-workspace-alive nil)
  (lsp-auto-execute-action nil)
  (lsp-before-save-edits nil)
  (lsp-eldoc-enable-hover nil)
  (lsp-diagnostic-package :none)
  (lsp-completion-provider :none)
  (lsp-file-watch-threshold 1500)  ; pyright has more than 1000
  (lsp-enable-links nil)
  (lsp-headerline-breadcrumb-enable nil)
  ;; Maybe set in future:
  ;;(lsp-enable-on-type-formatting nil)
  :custom-face
  (lsp-face-highlight-read ((t (:underline t :background nil :foreground nil))))
  (lsp-face-highlight-write ((t (:underline t :background nil :foreground nil))))
  (lsp-face-highlight-textual ((t (:underline t :background nil :foreground nil))))
  :hook
  (lsp-mode . lsp-enable-which-key-integration))

(use-package lsp-ui
  :after lsp-mode
  :custom
  (lsp-ui-doc-show-with-cursor nil)
  (lsp-ui-doc-show-with-mouse nil)
  (lsp-ui-doc-position 'at-point)
  (lsp-ui-sideline-delay 0.5)
  (lsp-ui-peek-always-show t)
  (lsp-ui-peek-fontify 'always)
  :custom-face
  (lsp-ui-peek-highlight ((t (:inherit nil :background nil :foreground nil :weight semi-bold :box (:line-width -1)))))
  :bind
  ( :map lsp-ui-mode-map
    ([remap xref-find-references] . lsp-ui-peek-find-references)
    ("C-M-l" . lsp-ui-peek-find-definitions)
    ("C-c C-d" . lsp-ui-doc-show))
  :config
  ;;;; LSP UI posframe ;;;;
  (defun lsp-ui-peek--peek-display (src1 src2)
    (-let* ((win-width (frame-width))
            (lsp-ui-peek-list-width (/ (frame-width) 2))
            (string (-some--> (-zip-fill "" src1 src2)
                      (--map (lsp-ui-peek--adjust win-width it) it)
                      (-map-indexed 'lsp-ui-peek--make-line it)
                      (-concat it (lsp-ui-peek--make-footer))))
            )
      (setq lsp-ui-peek--buffer (get-buffer-create " *lsp-peek--buffer*"))
      (posframe-show lsp-ui-peek--buffer
                     :string (mapconcat 'identity string "")
                     :min-width (frame-width)
                     :poshandler 'posframe-poshandler-frame-center)))

  (defun lsp-ui-peek--peek-destroy ()
    (when (bufferp lsp-ui-peek--buffer)
      (posframe-delete lsp-ui-peek--buffer))
    (setq lsp-ui-peek--buffer nil
          lsp-ui-peek--last-xref nil)
    (set-window-start (get-buffer-window) lsp-ui-peek--win-start))

  (advice-add 'lsp-ui-peek--peek-new :override 'lsp-ui-peek--peek-display)
  (advice-add 'lsp-ui-peek--peek-hide :override 'lsp-ui-peek--peek-destroy)
  ;;;; LSP UI posframe ;;;;
  )

(use-package yasnippet-snippets
  :straight (:host github :repo "KaratasFurkan/yasnippet-snippets" :branch "furkan")
  :after yasnippet)

(use-package rainbow-delimiters
  :hook (prog-mode . rainbow-delimiters-mode))

(use-package color-identifiers-mode
  :commands color-identifiers-mode)

(use-package symbol-overlay
  :commands (symbol-overlay-mode symbol-overlay-put fk/highlight-occurrences)
  :bind
  ( :map symbol-overlay-mode-map
    ("C-c C-n" . symbol-overlay-jump-next)
    ("C-c C-p" . symbol-overlay-jump-prev))
  :hook
  (emacs-lisp-mode . symbol-overlay-mode)
  (python-mode . symbol-overlay-mode)
  :config
  (defun fk/highlight-occurrences ()
    "Put highlight to the occurrences of the symbol at point or the
string in the region. Uses `hi-lock' to highlight,
`symbol-overlay' to generate a random face. To remove highlights,
use `hi-lock-unface-buffer' or disable `hi-lock-mode'."
    (interactive)
    (let ((str (fk/get-selected-text))
          (face (nth (random (length symbol-overlay-faces)) symbol-overlay-faces)))
      (if str
          (highlight-regexp (regexp-quote str) face)
        (hi-lock-face-symbol-at-point))))

  (defalias 'fk/highlight-remove (lambda () (interactive) (hi-lock-unface-buffer t)))
  (defalias 'fk/highlight-remove-one-by-one 'hi-lock-unface-buffer))

(use-package rainbow-mode
  :hook (prog-mode . rainbow-mode))

;; (use-package bug-reference
;;   :straight (:type built-in)
;;   ;; In default, this package is auto-activated and sometimes breaks syntax
;;   ;; highlighting by putting unrelevant bug-reference highlight and clickable
;;   ;; link.
;;   ;; E.g. `#112' at `my_color = "#112233"' gets bug-reference highlight.
;;   :disabled)

(use-package elisp-slime-nav
  :bind
  ( :map emacs-lisp-mode-map
    ("M-." . elisp-slime-nav-find-elisp-thing-at-point)))

;; TODO: try in other languages (html, css, js, c)
(use-package aggressive-indent
  :straight ( :host github
              :repo "KaratasFurkan/aggressive-indent-mode"
              :branch "146-emacs28-compatible-suppress-messages")
  :hook (emacs-lisp-mode . aggressive-indent-mode))

(use-package lisp-mode
  :straight (:type built-in)
  :hook
  (lisp-data-mode . (lambda ()
                      ;; NOTE: `emacs-lisp-mode' derives from `lisp-data-mode',
                      ;; so make sure that the major-mode is `lisp-data-mode'.
                      (when (string= major-mode "lisp-data-mode")
                        (fk/add-local-hook 'before-save-hook
                                           (lambda ()
                                             (align-regexp (point-min) (point-max) "\\(\\s-*\\). (")
                                             (fk/indent-buffer)))))))

(use-package python
  :straight (:type built-in)
  :init
  (add-to-list 'all-the-icons-icon-alist
               '("\\.py$" all-the-icons-alltheicon "python" :height 1.1 :face all-the-icons-dblue))
  :custom
  (python-shell-interpreter "ipython")
  (python-shell-interpreter-args "-i --simple-prompt")
  (python-indent-guess-indent-offset-verbose nil)
  :bind
  ( :map python-mode-map
    ("C-c r" . python-indent-shift-right)
    ("C-c l" . python-indent-shift-left))
  :hook
  ;; With pyls:
  ;; pip install python-language-server flake8 pyls-black(optional) pyls-isort(optional)
  ;; With pyright
  ;; sudo npm install -g pyright && pip install flake8 black(optional)
  ;; NOTE: these hooks runs in reverse order
  (python-mode . (lambda () (setq-local company-prescient-sort-length-enable nil)))
  (python-mode . (lambda () (unless (and buffer-file-name (file-in-directory-p buffer-file-name "~/.virtualenvs/"))
                              (flycheck-mode))))
  ;; (python-mode . lsp-deferred)
  ;;(python-mode . (lambda () (fk/add-local-hook 'before-save-hook 'eglot-format-buffer)))
  (python-mode . eglot-ensure)
  ;; importmagic runs ~100mb ipython process per python file, and it does not
  ;; always find imports, 60%-70% maybe. I stop using this, but still want to keep.
  ;; (python-mode . importmagic-mode)
  (python-mode . fk/activate-pyvenv)
  (python-mode . (lambda ()
                   (when (and (buffer-file-name)
                              (string=
                               (car (last (f-split (f-parent (buffer-file-name)))))
                               "tests"))
                     (fk/hide-second-level-blocks))))
  (python-mode . fk/tree-sitter-hl-mode)
  (python-mode . (lambda () (setq-local fill-column 88)))
  :config
  (defvar python-walrus-operator-regexp ":=")

  ;; Make walrus operator ":=" more visible
  (font-lock-add-keywords
   'python-mode
   `((,python-walrus-operator-regexp 0 'escape-glyph t))
   'set))

(use-package pyvenv
  :after python
  :config
  ;; I show this in `fk/minibuffer-modeline-update' manually.
  (setq pyvenv-mode-line-indicator nil)

  (defun fk/get-venv-name ()
    "Get venv name of current python project."
    (when-let* ((root-dir (projectile-project-root))
                (venv-file (concat root-dir ".venv"))
                (venv-exists (file-exists-p venv-file))
                (venv-name (with-temp-buffer
                             (insert-file-contents venv-file)
                             (nth 0 (split-string (buffer-string))))))
      venv-name))

  (defun fk/activate-pyvenv ()
    "Activate python environment according to the `project-root/.venv' file."
    (interactive)
    (when-let ((venv-name (fk/get-venv-name)))
      (pyvenv-mode)
      (pyvenv-workon venv-name)))

  (defun fk/open-venv-dir ()
    "Open the directory of installed libraries in `dired'."
    (interactive)
    (when-let* ((venv-name (fk/get-venv-name))
                (venv-dir (expand-file-name venv-name "~/.virtualenvs")))
      (dired (car (directory-files-recursively venv-dir "site-packages" t)))))

  ;; python-mode hook is not enough when more than one project's files are open.
  ;; It just re-activate pyvenv when a new file is opened, it should re-activate
  ;; on buffer or perspective switching too. NOTE: restarting lsp server is
  ;; heavy, so it should be done manually if needed.
  (add-hook 'window-configuration-change-hook 'fk/activate-pyvenv))

(use-package importmagic
  ;; pip install importmagic epc
  ;;
  ;; importmagic runs ~100mb ipython process per python file, and it does not
  ;; always find imports, 60%-70% maybe. I stop using this, but still want to keep.
  :commands importmagic-mode)

(use-package blacken
  :commands blacken-mode blacken-buffer)

(use-package py-isort
  :commands py-isort-buffer)

(use-package lsp-pyright
  :after lsp-mode
  :custom
  (lsp-pyright-auto-import-completions nil)
  (lsp-pyright-typechecking-mode "off")
  :config
  (fk/async-process
   "npm outdated -g | grep pyright | wc -l" nil
   (lambda (process output)
     (pcase output
       ("0\n" (message "Pyright is up to date."))
       ("1\n" (message "A pyright update is available."))))))

;; Search functions for Django

(fk/helm-rg-define-search-commands
 ("django-search-models"      django "m" "models.py"        "^class ")
 ("django-search-factories"   django "f" "factories.py"     "^class ")
 ("django-search-views"       django "v" "views*.py"        "^class ")
 ("django-search-serializers" django "s" "*serializers*.py" "^class ")
 ("django-search-tests"       django "t" "*test*.py"        "^class ")
 ("django-search-settings"    django "S" "*/settings/*"     "")
 ("django-search-admins"      django "a" "admin.py"         "^class admin( ")
 ("django-search-permissions" django "p" "permissions.py"   "^class ")
 ("django-search-mixins"      django "x" "mixins.py"        "^class ")
 ("django-search-urls"        django "u" "*.py"             "path( "))

;; Utility functions for Django

(defcustom fk/django-test-args "" "Should be set as directory local variable.")

(defun fk/django-get-module ()
  "pony-get-module originally."
  (let* ((root (projectile-project-root))
         (path (file-name-sans-extension (or buffer-file-name (expand-file-name default-directory)))))
    (when (string-match (projectile-project-root) path)
      (let ((path-to-class (substring path (match-end 0))))
        (mapconcat 'identity (split-string path-to-class "/") ".")))))

(defun fk/django-copy-path-of-test-at-point ()
  "Add path of the test at point to kill-ring. Returns the path."
  (interactive)
  (require 'which-func)
  (let* ((defuns (seq-subseq (split-string (which-function) "\\.") 0 2))
         (class (car defuns))
         (func (let ((f (-second-item defuns))) (and f (string-match "^test" f) f)))
         (module (fk/django-get-module))
         (path (concat module (and module class ".") class (and class func ".") func)))
    (kill-new path)))

(defun fk/django-run-test-at-point ()
  "Run test at point."
  (interactive)
  (fk/django-copy-path-of-test-at-point)
  (let ((vterm-buffer (save-window-excursion
                        (fk/projectile-vterm)
                        (current-buffer))))
    (if (window-live-p (get-buffer-window vterm-buffer))
        (select-window (get-buffer-window vterm-buffer))
      (fk/projectile-vterm)))
  (vterm-insert (format "python manage.py test --keepdb %s %s" fk/django-test-args
                        (substring-no-properties (pop kill-ring)))))

(bind-keys*
 :map django
 ("c" . fk/django-copy-path-of-test-at-point)
 ("d" . fk/django-run-test-at-point))

(use-package ein
  :commands ein:run
  :custom-face
  (ein:cell-input-area ((t (:background "#21262E"))))
  :hook
  (ein:ipynb-mode . fk/activate-pyvenv))

(use-package web-mode
  :custom
  (css-indent-offset 2)
  (web-mode-markup-indent-offset 2)
  (web-mode-enable-auto-indentation nil)
  (web-mode-enable-auto-pairing nil)
  (web-mode-engines-alist '(("django" . "\\.html\\'")))
  :custom-face
  (web-mode-block-string-face ((t (:inherit font-lock-string-face))))
  (web-mode-html-attr-value-face ((t (:inherit font-lock-string-face :foreground nil))))
  (web-mode-current-element-highlight-face ((t (:inherit highlight))))
  :mode ;; Copied from spacemacs
  (("\\.phtml\\'"      . web-mode)
   ("\\.tpl\\.php\\'"  . web-mode)
   ("\\.twig\\'"       . web-mode)
   ("\\.xml\\'"        . web-mode)
   ("\\.html\\'"       . web-mode)
   ("\\.htm\\'"        . web-mode)
   ("\\.[gj]sp\\'"     . web-mode)
   ("\\.as[cp]x?\\'"   . web-mode)
   ("\\.eex\\'"        . web-mode)
   ("\\.erb\\'"        . web-mode)
   ("\\.mustache\\'"   . web-mode)
   ("\\.handlebars\\'" . web-mode)
   ("\\.hbs\\'"        . web-mode)
   ("\\.eco\\'"        . web-mode)
   ("\\.ejs\\'"        . web-mode)
   ("\\.svelte\\'"     . web-mode)
   ("\\.djhtml\\'"     . web-mode)
   ("\\.mjml\\'"       . web-mode))
  :hook
  (web-mode . web-mode-toggle-current-element-highlight))

(use-package emmet-mode
  :custom
  (emmet-move-cursor-between-quotes t)
  :custom-face
  (emmet-preview-input ((t (:inherit lazy-highlight))))
  :bind
  ( :map emmet-mode-keymap
    ([remap yas-expand] . emmet-expand-line)
    ("M-n"  . emmet-next-edit-point)
    ("M-p"  . emmet-prev-edit-point)
    ("C-c p" . emmet-preview-mode))
  :hook
  ;;(rjsx-mode . (lambda () (setq emmet-expand-jsx-className? t)))
  (web-mode . emmet-mode)
  (css-mode . emmet-mode))

(use-package helm-emmet
  :after helm emmet)

(use-package company-web
  :after web-mode
  :config
  (add-to-list 'company-backends '(company-web-html :with company-yasnippet)))

(use-package json-mode
  :mode ("\\.json\\'" . json-mode))
(use-package json-navigator
  :commands json-navigator-navigate-region)