;;; $doomdir/config.el --- My Emacs Config File -*- lexical-binding: t; -*-
;;
;; author: Marty Buchaus <marty@dabuke.com>
;; copyright © 2022, Marty Buchaus, all rights reserved.
;;
;;; Commentary:
;;
;;; Code:
;;;; Global

(setq user-full-name "Marty Buchaus")
(setq user-mail-address "marty@dabuke.com")

(setq-default epg-gpg-program "/usr/bin/gpg2")
(setq-default delete-by-moving-to-trash t)
(setq-default enable-local-variables t)            ; allow for reading the local variables file
(setq-default left-margin-width 1)                 ; Define new widths
(setq-default right-margin-width 2)                ; Define new widths.
(setq-default window-combination-resize t)
(setq-default x-stretch-cursor t)
(setq-default display-time-24hr-format t)                  ; I wonder what this does
(setq-default evil-want-fine-undo t)                       ; by default while in insert all changes are one big blob. be more granular
(setq-default truncate-string-ellipsis "…")                ; unicode ellispis are nicer than "...", and also save /precious/ space
(setq-default auth-sources '("~/.authinfo.gpg"))
(setq-default warning-minimum-level :emergency)
(setq-default doom-scratch-initial-major-mode 'lisp-interaction-mode)  ; Make the scratch buffer start in lisp mode
(setq-default display-time-load-average nil)
(setq auto-save-default t)                         ; nobody likes to loose work, i certainly don't
(setq confirm-kill-emacs nil)                      ; stop hounding me and quit
(setq inhibit-compacting-font-caches t)
(setq password-cache-expiry nil)                   ; i can trust my computers ... can't i?
(setq read-process-output-max (* 1024 1024))
(setq scroll-margin 2)                             ; it's nice to maintain a little margin
(setq undo-limit 80000000)                         ; raise undo-limit to 80mb

(setq garbage-collection-messages nil)

(display-time-mode 1)                              ; enable time in the mode-line
(global-subword-mode 1)                            ; CamelCase and it makes refactoring slightly Essie

(set-window-buffer nil (current-buffer))

(add-to-list 'load-path (expand-file-name "elisp/" doom-user-dir))

(setq safe-local-variable-values
      (quote
       ((buffer-read-only . 1))))

(doom-load-envvars-file (expand-file-name ".local/env" doom-emacs-dir))

;;;;; Vterm

(setq-default vterm-kill-buffer-on-exit t)
(setq-default vterm-always-compile-module t)               ; Always compile the vterm module
(setq-default vterm-timer-delay nil)                       ; Make Vterm snappier
(setq-default vterm-shell "/usr/bin/zsh")

;;;; Key Bindings

(setq-default doom-localleader-key ",")

;;;;; global Keybindings

(define-key! help-map
   "h"    #'helpful-at-point)

(global-set-key [f7] 'hyrolo-fgrep)

(after! evil
  (map! :m  "-"  #'dired-jump
        :en "C-h"   #'evil-window-left
        :en "C-j"   #'evil-window-down
        :en "C-k"   #'evil-window-up
        :en "C-l"   #'evil-window-right))

(map!
 :n "C-:"    #'flyspell-correct-wrapper
 :n "gz"     #'zoxide-find-file
 :n "C-,"    #'flyspell-correct-next)


;;;;; Leader KeyBindings

(map! :leader
      "TAB"  #'evil-switch-to-windows-last-buffer
      "SPC"  #'execute-extended-command)

;;;;;; <leader> a --- Application

(map! :leader
      (:prefix-map ("a" . "app")
       :desc "MU4E"              "m"  #'=mu4e
       :desc "Dashboard"         "d"  #'+doom-dashboard/open
       ;; :desc "consult-recoll"    "r"  #'consult-recoll
       :desc "Paperless"         "P"  #'paperless
       :desc "Xeft-mode"         "x"  #'xeft
       (:prefix-map ("b" . "buku")
                    "b"  #'ebuku
                    "s"  #'ebuku-search-on-all)
       ;; Pass
       (:when (modulep! :tools pass)
         (:prefix-map ("p" . "pass")
                      "/"  #'+pass/consult
                      "c"  #'password-store-edit
                      "d"  #'password-store-remove
                      "g"  #'password-store-generate
                      "i"  #'password-store-insert
                      "r"  #'password-store-rename
                      "w"  #'password-store-url
                      "y"  #'password-store-copy
                      "D"  #'password-store-clear
                      "I"  #'password-store-init))
       (:prefix-map ("o" . "otp")
                    "a" #'password-store-otp-append
                    "i" #'password-store-otp-insert
                    "y" #'password-store-otp-token-copy
                    "A" #'password-store-otp-append-from-image
                    "Y" #'password-store-otp-uri-copy)
       ;; Tramp
       (:prefix-map ("t" . "Tramp")
        :desc "clean all connections" "C"  #'tramp-cleanup-all-connections
        :desc "clean all buffers"     "B"  #'tramp-cleanup-all-buffers
        :desc "clean connection"      "c"  #'tramp-cleanup-this-connection
        :desc "consult-tramp"         "t"  #'consult-tramp
        :desc "tramp-quit"            "q"  #'marty/tramp-quit)))

;; ;;;;;; <leader> b
;; (map! :leader
;;       :prefix ("b")
;;       "b"  #'consult-buffer)

;;;;;; <leader> d ---

(map! :leader
      (:prefix-map ("d" . "Dired")
       :desc "Peep-dired image previews"   "p"  #'peep-dired
       :desc "Dired-FD"                    "d"  #'fd-dired
       :desc "Dired Jump"                  "j"  #'dired-jump
       :desc "Dired Jump o/window"         "J"  #'dired-jump-other-window
       :desc "Dired view file"             "v"  #'dired-view-file))

;;;;;; <leader> f --- file

(map! :leader
      (:prefix ("f")
       :desc "Search Directory FD"         "/"   #'+vertico/consult-fd))

;;;;;; <leader> l --- workspace / Layout

(map! :leader
      :prefix-map ("l" . "workspace")
      :desc "Display tab bar"           "SPC" #'+workspace/display
      :desc "Cycle tab bar"             "TAB" #'+workspace/cycle
      :desc "Switch workspace"          "."   #'+workspace/switch-to
      :desc "Switch to last workspace"  "`"   #'+workspace/other
      :desc "Move workspace left"       "<"   #'+workspace/swap-left
      :desc "Move workspace right"      ">"   #'+workspace/swap-right
      :desc "New workspace"             "n"   #'+workspace/new
      :desc "Create named workspace"    "N"   #'+workspace/new-named
      :desc "open workspace from file"  "o"   #'+workspace/load
      :desc "Save workspace to file"    "s"   #'+workspace/save
      :desc "Delete session"            "x"   #'+workspace/kill-session
      :desc "Delete this workspace"     "d"   #'+workspace/delete
      :desc "Rename workspace"          "r"   #'+workspace/rename
      :desc "Switch workspace"          "l"   #'+workspace/switch-to
      :desc "Restore last session"      "R"   #'+workspace/restore-last-session
      :desc "Next workspace"            "]"   #'+workspace/switch-right
      :desc "Previous workspace"        "["   #'+workspace/switch-left
      :desc "Switch to 1st workspace"   "1"   #'+workspace/switch-to-0
      :desc "Switch to 2nd workspace"   "2"   #'+workspace/switch-to-1
      :desc "Switch to 3rd workspace"   "3"   #'+workspace/switch-to-2
      :desc "Switch to 4th workspace"   "4"   #'+workspace/switch-to-3
      :desc "Switch to 5th workspace"   "5"   #'+workspace/switch-to-4
      :desc "Switch to 6th workspace"   "6"   #'+workspace/switch-to-5
      :desc "Switch to 7th workspace"   "7"   #'+workspace/switch-to-6
      :desc "Switch to 8th workspace"   "8"   #'+workspace/switch-to-7
      :desc "Switch to 9th workspace"   "9"   #'+workspace/switch-to-8
      :desc "Switch to final workspace" "0"   #'+workspace/switch-to-final)

;;;;;; <leader> n --- notes

(map! :leader
      :prefix "n"
      "r" #'transient-roam-jump)

;;;;;; <leader> o --- open

(map! :leader
      (:prefix ("o")
               (:prefix-map ("m" . "My")
                :desc "0mobile"       "0" #'(lambda () (interactive) (find-file (concat org-directory "0mobile.org")))
                :desc "Bullets"       "b" #'(lambda () (interactive) (find-file (concat org-directory "Joyent/Bullets.org")))
                :desc "Desktop"       "d" #'(lambda () (interactive) (find-file (concat org-directory "desktop.org")))
                :desc "MD Cheat"      "D" #'(lambda () (interactive) (find-file "~/Nextcloud/Notes/markdown/markdown-cheat-sheet.md"))
                :desc "contacts"      "o" #'(lambda () (interactive) (find-file (concat org-directory "contacts.org")))
                :desc "read-later"    "r" #'(lambda () (interactive) (find-file (concat org-directory "read-later.org")))
                :desc "Tasks"         "g" #'(lambda () (interactive) (find-file (concat org-directory "Tasks.org")))
                :desc "Habits"        "h" #'(lambda () (interactive) (find-file (concat org-directory "Habits.org")))
                :desc "Joyent Index"  "j" #'(lambda () (interactive) (find-file (concat org-directory "Joyent/index.org")))
                :desc "read later"    "l" #'(lambda () (interactive) (find-file (concat org-directory "read-later.org")))
                :desc "Projects"      "p" #'(lambda () (interactive) (find-file (concat org-directory "Projects.org")))
                :desc "Someday"       "s" #'(lambda () (interactive) (find-file (concat org-directory "Someday.org")))
                :desc "Tip Jar"       "t" #'(lambda () (interactive) (find-file (concat org-directory "TipJar/index.org"))))
               (:prefix-map ("c" . "+config")
                :desc "keybindings"  "k" #'(lambda () (interactive) (find-file (concat doom-private-dir "keybindings.el")))
                :desc "config"       "c" #'(lambda () (interactive) (find-file (concat doom-private-dir "config.el")))
                :desc "org"          "o" #'(lambda () (interactive) (find-file (concat doom-private-dir "org-mode.el")))
                :desc "init"         "i" #'(lambda () (interactive) (find-file (concat doom-private-dir "init.el")))
                :desc "packages"     "p" #'(lambda () (interactive) (find-file (concat doom-private-dir "packages.el")))
                :desc "mu4e"         "m" #'(lambda () (interactive) (find-file (concat doom-private-dir "mu4e.el"))))
               (:prefix-map ("C" . "calendar")
                :desc "Calendar"      "C" #'(lambda () (interactive) (find-file (concat org-directory "snuffop-calendar.org")))
                :desc "Joyent-Calendar" "j" #'(lambda () (interactive) (find-file (concat org-directory "joyent-calendar.org"))))))


;;;; UI
;;;;; Set Fonts


(cond (IS-MAC (setq doom-font (font-spec :family "DejaVuSansMono Nerd Font Mono" :size 13)
                    doom-variable-pitch-font (font-spec :family "Ubuntu Nerd Font" :style "Regular" :size 13 :weight 'regular)))
      (IS-LINUX (setq doom-font (font-spec :family "FiraCode Nerd Font" :size 13 :weight 'medium)
                      doom-big-font (font-spec :family "FiraCode Nerd Font" :size 21 :weight 'regular)
                      doom-variable-pitch-font (font-spec :family "Ubuntu" :size 14)
                      doom-unicode-font (font-spec :family "Noto Color Emoji" :size 15))))

;;;;; Faces

(custom-set-faces!
  '(font-lock-comment-face :slant italic)
  '(font-lock-keyword-face :slant italic))
(setq global-prettify-symbols-mode t)

(cond (IS-MAC
       (custom-set-faces!
         '(mode-line :family "firacode nerd font mono" :height 140)
         '(mode-line-inactive :family "firacode nerd font mono" :height 140)))
      (t
       (custom-set-faces!
         '(mode-line :family "Ubuntu Nerd Font" :height 105)
         '(mode-line-inactive :family "Ubuntu Nerd Font" :height 105))))

;;;;; Theme

(setq doom-theme 'doom-dracula)

(remove-hook 'window-setup-hook #'doom-init-theme-h)
(add-hook 'after-init-hook #'doom-init-theme-h 'append)
(delq! t custom-theme-load-path)

(custom-set-faces!
  '(doom-modeline-buffer-modified :foreground "orange"))

(after! doom-themes
  (doom-themes-org-config)
  (doom-themes-visual-bell-config)
  (doom-themes-treemacs-config)
  (setq doom-themes-enable-bold t
        doom-themes-enable-italic t
        doom-themes-padded-modeline t
        doom-themes-treemacs-theme 'doom-colors))


;;;;; Modeline

(after! doom-modeline
  (setq auto-revert-check-vc-info t
        doom-modeline-buffer-file-name-style 'relative-to-project
        doom-modeline-enable-word-count t
        doom-modeline-github t
        doom-modeline-major-mode-color-icon (display-graphic-p)
        doom-modeline-major-mode-icon (display-graphic-p)
        doom-modeline-mu4e t
        doom-modeline-buffer-state-icon t
        doom-modeline-buffer-modification-icon t
        doom-modeline-modal-icon nil
        doom-modeline-vcs-max-length 60)

  (set-face-attribute 'mode-line nil :family "Ubuntu" :height 100)
  (set-face-attribute 'mode-line-inactive nil :family "Ubuntu" :height 100)

  (add-hook! 'doom-modeline-mode-hook
    (progn
      (set-face-attribute 'header-line nil
                          :background (face-background 'mode-line)
                          :foreground (face-foreground 'mode-line))))
                          

  (doom-modeline-def-segment buffer-name
    "Display the current buffer's name, without any other information."
    (concat
     (doom-modeline-spc)
     (doom-modeline--buffer-name)))

  (doom-modeline-def-segment pdf-icon
    "PDF icon from all-the-icons."
    (concat
     (doom-modeline-spc)
     (doom-modeline-icon 'octicon "file-pdf" nil nil
                         :face (if (doom-modeline--active)
                                   'all-the-icons-red
                                 'mode-line-inactive)
                         :v-adjust 0.02))))



;;;;; Dashboard

(setq doom-fallback-buffer-name "► Doom"
      +doom-dashboard-name "► Doom")

(custom-theme-set-faces! 'doom-one
  '(doom-dashboard-banner :foreground "red" :background "#000000" :weight bold)
  '(doom-dashboard-footer :inherit font-lock-constant-face)
  '(doom-dashboard-footer-icon :inherit all-the-icons-red)
  '(doom-dashboard-loaded :inherit font-lock-warning-face)
  '(doom-dashboard-menu-desc :inherit font-lock-string-face)
  '(doom-dashboard-menu-title :inherit font-lock-function-name-face))

(setq fancy-splash-image (expand-file-name "banners/smaller-cute-demon.png" doom-private-dir))


;;;;; Line Numbers

(setq display-line-numbers-type 'relative)

;; remove numbers from these modes
(dolist (mode '(org-mode-hook
                term-mode-hook
                shell-mode-hook
                eshell-mode-hook))
  (add-hook mode (lambda () (display-line-numbers-mode 0))))

(setq doom-fallback-buffer-name "► Doom"
      +doom-dashboard-name "► Doom")

;;;;; Syntax Lists

(add-to-list 'auto-mode-alist '("\\.service\\'" . systemd-mode))
(add-to-list 'auto-mode-alist '("\\.service.tmpl\\'" . systemd-mode))
(add-to-list 'auto-mode-alist '("\\.timer\\'" . systemd-mode))
(add-to-list 'auto-mode-alist '("\\.timer.tmpl\\'" . systemd-mode))
(add-to-list 'auto-mode-alist '("\\.target\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.mount\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.automount\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.slice\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.socket\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.path\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.netdev\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.network\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.link\\'" . conf-unix-mode))
(add-to-list 'auto-mode-alist '("\\.j2\\'" . jinja2-mode))
(add-to-list 'auto-mode-alist '("hosts" . conf-mode))

;;;;; Windows

(setq evil-vsplit-window-right t
      evil-split-window-below t)

;;;; PACKAGES
;;;;; Autoinsert

(defun marty/autoinsert-yas-expand ()
  "Auto Insert Funtion that works for me."
  (let ((template ( buffer-string)))
    (delete-region (point-min) (point-max))
    (yas-expand-snippet template)
    (evil-insert-state)))

(use-package! autoinsert
  :init
  (setq auto-insert-query nil)
  (setq auto-insert-directory (expand-file-name "templates" doom-private-dir))
  (add-hook 'find-file-hook 'auto-insert)
  (auto-insert-mode 1)
  :config
  (define-auto-insert "\\.html?$" ["default.html" marty/autoinsert-yas-expand])
  (define-auto-insert "\\.org" ["default.org" marty/autoinsert-yas-expand])
  (define-auto-insert "\\.sh" ["default.sh" marty/autoinsert-yas-expand])
  (define-auto-insert "\\.el" ["default.el" marty/autoinsert-yas-expand])
  (define-auto-insert "Roam/.+\\.org?$" ["org-roam-mode/defaultRoam.org" marty/autoinsert-yas-expand])
  (define-auto-insert "masons/[^/].+\\.org?$" ["org-mode/masonsMeetingMinuets.org" marty/autoinsert-yas-expand])
  (define-auto-insert "daily/[^/].+\\.org?$" ["org-roam-mode/defaultRoamDaily.org" marty/autoinsert-yas-expand]))


;;;;; Completion

(setq  completion-styles '(orderless basic substring partial-compltion  flex))
(setq  read-file-name-completion-ignore-case t)
(setq  read-buffer-completion-ignore-case t)
(setq  completion-ignore-case t)

;;;;;; Vertico

(after! vertico
  (vertico-reverse-mode 1)
  (setq vertico-resize t))


;;;;;; Embark
;; Open files in (Option) after C-; in embark
;;
(defun my/vsplit-file-open (file)
  "Vertically Split FILE below current."
  (let ((evil-split-window-below t))
    (+evil/window-vsplit-and-follow)
    (find-file file)))

(defun my/split-file-open (file)
  "Split Window Below Current opening FILE."
  (let ((evil-split-window-below t))
    (+evil/window-split-and-follow)
    (find-file file)))

(map! :after embark
      :map embark-file-map
      "V" 'my/vsplit-file-open
      "X" 'my/split-file-open)

;;;;;; Marginalia

(after! marginalia
  (setq marginalia-censor-variables nil)

  (defadvice! +marginalia--anotate-local-file-colorful (cand)
    "Just a more colourful version of `marginalia--anotate-local-file'."
    :override #'marginalia--annotate-local-file
    (when-let (attrs (file-attributes (substitute-in-file-name
                                       (marginalia--full-candidate cand))
                                      'integer))
      (marginalia--fields
       ((marginalia--file-owner attrs)
        :width 12 :face 'marginalia-file-owner)
       ((marginalia--file-modes attrs))
       ((+marginalia-file-size-colorful (file-attribute-size attrs))
        :width 7)
       ((+marginalia--time-colorful (file-attribute-modification-time attrs))
        :width 12))))

  (defun +marginalia--time-colorful (time)
    (let* ((seconds (float-time (time-subtract (current-time) time)))
           (color (doom-blend
                   (face-attribute 'marginalia-date :foreground nil t)
                   (face-attribute 'marginalia-documentation :foreground nil t)
                   (/ 1.0 (log (+ 3 (/ (+ 1 seconds) 345600.0)))))))
      ;; 1 - log(3 + 1/(days + 1)) % grey
      (propertize (marginalia--time time) 'face (list :foreground color))))

  (defun +marginalia-file-size-colorful (size)
    (let* ((size-index (/ (log10 (+ 1 size)) 7.0))
           (color (if (< size-index 10000000) ; 10m
                      (doom-blend 'orange 'green size-index)
                    (doom-blend 'red 'orange (- size-index 1)))))
      (propertize (file-size-human-readable size) 'face (list :foreground color)))))


;;;;;; Consult

(after! consult
  (evil-collection-init 'consult)
  (set-face-attribute 'consult-file nil :inherit 'consult-buffer)
  (setf (plist-get (alist-get 'perl consult-async-split-styles-alist) :initial) ";"))

;;;;;; Consult-Recoll

;; (defun my-recoll-format (title url mime-type)
;;   "remove from url the common prefixes /home/jao/{org/doc,doc,..."
;;   (let* ((u (replace-regexp-in-string "/home/marty/" "" url))
;;          (u (replace-regexp-in-string
;;              "\\(doc\\|org/doc\\|.emacs.d/gnus/Mail\\|var/mail\\)/" "" u)))
;;     (format "%s (%s, %s)"
;;             (propertize title 'face 'consult-recoll-title-face)
;;             (propertize u 'face 'consult-recoll-url-face)
;;             (propertize mime-type 'face 'consult-recoll-mime-face))))

;; (setq consult-recoll-format-candidate #'my-recoll-format)

;;;;; Chezmoi

(use-package! chezmoi
  :commands (chezmoi-write
             chezmoi-magit-status
             chezmoi-diff
             chezmoi-ediff
             chezmoi-find
             chezmoi-write-files
             chezmoi-open-other
             chezmoi-template-buffer-display
             chezmoi-mode)
  :config
  ;; Company integration
  (when (modulep! :completion company)
    (defun +chezmoi--company-backend-h ()
      (require 'chezmoi-company)
      (if chezmoi-mode
          (add-to-list 'company-backends 'chezmoi-company-backend)
        (delete 'chezmoi-company-backend 'company-backends)))

    (add-hook 'chezmoi-mode-hook #'+chezmoi--company-backend-h))

  ;; Integrate with evil mode by toggling template display when entering insert mode.
  (when (modulep! :editor evil)
    (defun +chezmoi--evil-insert-state-enter-h ()
      "Run after evil-insert-state-entry."
      (chezmoi-template-buffer-display nil (point))
      (remove-hook 'after-change-functions #'chezmoi-template--after-change 1))

    (defun +chezmoi--evil-insert-state-exit-h ()
      "Run after evil-insert-state-exit."
      (chezmoi-template-buffer-display nil)
      (chezmoi-template-buffer-display t)
      (add-hook 'after-change-functions #'chezmoi-template--after-change nil 1))

    (defun +chezmoi--evil-h ()
      (if chezmoi-mode
          (progn
            (add-hook 'evil-insert-state-entry-hook #'+chezmoi--evil-insert-state-enter-h nil 1)
            (add-hook 'evil-insert-state-exit-hook #'+chezmoi--evil-insert-state-exit-h nil 1))
        (progn
          (remove-hook 'evil-insert-state-entry-hook #'+chezmoi--evil-insert-state-enter-h 1)
          (remove-hook 'evil-insert-state-exit-hook #'+chezmoi--evil-insert-state-exit-h 1))))

    (add-hook 'chezmoi-mode-hook #'+chezmoi--evil-h)))

(map! :leader :prefix "a"
      (:prefix ("c" . "chezmoi")
       :desc "Magit status" "g" #'chezmoi-magit-status
       :desc "Write"        "w" #'chezmoi-write
       :desc "Write files"  "W" #'chezmoi-write-files
       :desc "Find source"  "f" #'chezmoi-find
       :desc "Sync files"   "s" #'chezmoi-sync-files
       :desc "Diff"         "d" #'chezmoi-diff
       :desc "EDiff"        "e" #'chezmoi-ediff
       :desc "Open other"   "o" #'chezmoi-open-other))

;;;;; Circe

(after! circe
  (setq circe-use-cycle-completion t)
  (setq circe-reduce-lurker-spam t)
  (setq circe-format-server-topic "*** Topic change by {userhost}: {topic-diff}")
  (setq circe-format-say "{nick:-16s} {body}")
  (circe-set-display-handler "JOIN" (lambda (&rest ignored) nil))

  (set-irc-server! "irc.libera.chat"
    `(:tls t
      :port 6697
      :nick "snuffop"
      :sasl-username ,(+pass-get-user   "irc/libera.chat")
      :sasl-password ,(+pass-get-secret "irc/libera.chat")
      :channels ("#doomemacs" "#b0fh"))))

;;;;; Consult-Tramp

(use-package! consult-tramp
  :commands (consult-tramp)
  :config
  (setq consult-tramp-extra-targets '("/sshx:mail.dabuke.com|sudo:mail.dabuke.com:/")))

;;;;; Company

(after! company
  (setq company-idle-delay 0.2
        company-minimum-prefix-length 1
        company-tooltip-align-annotations t
        company-selection-wrap-around t
        company-backends '(company-capf company-dabbrev company-files company-yasnippet)
        company-global-modes '(not comint-mode erc-mode message-mode help-mode gud-mode)))

;;;;; DIRed

(define-key! dired-mode-map
  (kbd "C-t") #'marty/dired-copy-filename-as-tsfile-link)

(setq delete-by-moving-to-trash t
      trash-directory "~/.local/share/Trash/files/")

;;;;; Dirvish

(use-package! diredfl
  :hook (dired-mode . diredfl-mode)
  :hook (dirvish-directory-view-mode . diredfl-mode))


(use-package! dirvish
  :defer t
  :general (dired-mode-map "C-c C-r" #'dirvish-rsync)
  :after-call dired-noselect dired dired-jump
  :custom
  (dirvish-quick-access-entries
   '(("." "~/.config/"                 "config")
     ("h" "~/"                         "Home")
     ("c" "~/.local/share/chezmoi/"    "chezmoi")
     ("d" "~/Downloads/"               "Downloads")
     ("p" "~/Nextcloud/Pictures"       "Pictures")
     ("s" "~/Source"                   "Source")
     ("S" "~/Sites"                    "Sites")
     ("t" "~/.local/share/Trash/files" "TrashCan")))
  :config
  (dirvish-override-dired-mode)
  (setq dirvish-cache-dir (concat doom-cache-dir "dirvish/"))
  (set-popup-rule! "^ ?\\*Dirvish.*" :ignore t)
  (map! :map dirvish-mode-map
        :n  "?"   #'dirvish-dispatch
        :n  "q"   #'dirvish-quit
        :ng "a"   #'dirvish-quick-access
        :ng "f"   #'dirvish-file-info-menu
        :ng "y"   #'dirvish-yank-menu
        :ng "s"   #'dirvish-quicksort
        :ng "TAB" #'dirvish-subtree-toggle
        :ng "M-t" #'dirvish-layout-toggle
        :ng "M-b" #'dirvish-history-go-backward
        :ng "M-f" #'dirvish-history-go-forward
        :ng "M-n" #'dirvish-narrow
        :ng "M-m" #'dirvish-mark-menu
        :ng "M-s" #'dirvish-setup-menu
        :ng "M-e" #'dirvish-emerge-menu)
  (setq dirvish-attributes '(file-size collapse)
        dirvish-mode-line-format
        '(:left (sort file-time symlink) :right (omit yank index)))
  (setq dirvish-attributes nil
        dirvish-use-header-line nil
        dirvish-mode-line-format nil
        dirvish-hide-details nil
        dirvish-hide-cursor nil)
  (when (modulep! :ui vc-gutter)
    (push 'vc-state dirvish-attributes))
  (when (modulep! +icons)
    (appendq! dirvish-attributes '(all-the-icons subtree-state))))

;;;;; ebuku

(use-package! ebuku
  :commands ebuku
  :init
  (+evil-collection-init 'ebuku)
  :config
  (evil-collection-ebuku-setup))

;;;;; evil

(global-evil-matchit-mode 1)

;;;;; Evil keys in DIRed

(map! :after dired
      :map dired-mode-map
      :localleader
      :desc "Create TSfile link"   "t"  #'marty/dired-copy-filename-as-tsfile-link)

(evil-define-key 'normal dired-mode-map
  (kbd "M-RET") 'dired-display-file
  (kbd "h") 'dired-up-directory
  (kbd "l") 'dired-view-file
  (kbd "m") 'dired-mark
  (kbd "t") 'dired-toggle-marks
  (kbd "u") 'dired-unmark
  (kbd "C") 'dired-do-copy
  (kbd "D") 'dired-do-delete
  (kbd "J") 'dired-goto-file
  (kbd "M") 'dired-chmod
  (kbd "O") 'dired-chown
  (kbd "P") 'dired-do-print
  (kbd "R") 'dired-do-rename
  (kbd "T") 'dired-do-touch
  (kbd "Y") 'dired-copy-filenamecopy-filename-as-kill ; copies filename to kill ring.
  (kbd "+") 'dired-create-directory
  (kbd "-") 'dired-up-directory
  (kbd "% l") 'dired-downcase
  (kbd "% u") 'dired-upcase
  (kbd "* %") 'dired-mark-files-regexp
  (kbd "* .") 'dired-mark-extension
  (kbd "* /") 'dired-mark-directories
  (kbd "; d") 'epa-dired-do-decrypt
  (kbd "; e") 'epa-dired-do-encrypt
  (kbd "; d") 'epa-dired-do-decrypt
  (kbd "; e") 'epa-dired-do-encrypt)

(add-hook 'peep-dired-hook 'evil-normalize-keymaps)
;;
;; get file icons in dired
(add-hook 'dired-mode-hook 'all-the-icons-dired-mode)
;; with dired-open plugin, you can launch external programs for certain extensions
;; for example, i set all .png files to open in 'sxiv' and all .mp4 files to open in 'mpv'
(setq dired-open-extensions '(("gif" . "sxiv")
                              ("jpg" . "sxiv")
                              ("png" . "sxiv")
                              ("mkv" . "mpv")
                              ("mp4" . "mpv")))

;;;;; EWW

(map! :leader
      :desc "Search web for text between BEG/END"
      "s w" #'eww-search-words
      (:prefix ("e" . "evaluate/ERC/EWW")
       :desc "Eww web browser" "w" #'eww
       :desc "Eww reload page" "R" #'eww-reload))
;;;;; EROS

(setq eros-eval-result-prefix "⟹ ")

;;;;; Flycheck

(use-package! flycheck-org-vale
  :after org flycheck)

(use-package flycheck-title
  :after flycheck
  :config
  (flycheck-title-mode))

;;;;; Google Translate

(use-package! google-translate
  :defer t
  :bind ("C-c T"  . 'google-translate-smooth-translate))


;;;;; Info-colors

(use-package! info-colors
  :commands (info-colors-fontify-node)
  :init
  (add-hook 'Info-selection-hook 'info-colors-fontify-node))

;;;;; I3 window manager config

;; Syntax highlighting for i3 config
(use-package! i3wm-config-mode
  :defer t)

;;;;; keychain-environment

(use-package! keychain-environment
  :init
  (keychain-refresh-environment))

;;;;; Magit

(after! magit
  (add-hook 'git-commit-setup-hook 'git-commit-turn-on-flyspell)
  (magit-todos-mode 1)
  (magit-delta-mode +1)
  (add-hook 'magit-add-section-hook 'magit-status-selections-hook
                          'magit-insert-modules
                          'magit-insert-unpulled-from-upstream)
  (setq magit-module-sections-nested nil)
  (setq magit-diff-refine-hunk 'all)
  (setq magit-revision-show-gravatars '("^author:     " . "^commit:     ")))

;;;;; Markdown

(custom-set-faces
 '(markdown-header-face ((t (:inherit font-lock-function-name-face :weight bold :family "variable-pitch"))))
 '(markdown-header-face-1 ((t (:inherit markdown-header-face :height 1.7))))
 '(markdown-header-face-2 ((t (:inherit markdown-header-face :height 1.6))))
 '(markdown-header-face-3 ((t (:inherit markdown-header-face :height 1.5))))
 '(markdown-header-face-4 ((t (:inherit markdown-header-face :height 1.4))))
 '(markdown-header-face-5 ((t (:inherit markdown-header-face :height 1.3))))
 '(markdown-header-face-6 ((t (:inherit markdown-header-face :height 1.2)))))

;;;;;; Grip

(after! grip-mode
  (setq grip-github-password (auth-source-pass-get 'secret "Application/github.com/emacs-token")))

;;;;; mixed pitch

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

;;;;; neopastebin

(use-package! neopastebin
  :commands
  pastebin-list-buffer-refresh
  pastebin-new
  :config
  (let ((credentials (auth-source-user-and-password "pastebin.com")))
    (pastebin-create-login :username "snuffop"
                           :dev-key (car credentials)
                           :password (cadr credentials))))

;;;;; nginx

(use-package! company-nginx
  :after nginx-mode
  :config
  (add-hook 'nginx-mode-hook (lambda () (add-to-list 'company-backends #'company-nginx))))

(use-package! nginx-mode
  :commands (nginx-mode)
  :defer t)

;;;;; outshine

(use-package! outshine
  :hook (prog-mode . outshine-mode)
  :config
  (map! :map emacs-lisp-mode-map
        "TAB" #'outshine-cycle)
  (add-hook 'prog-mode-hook #'outline-minor-mode)
  (add-hook 'outline-minor-mode-hook #'outshine-mode)
  (defvar outline-minor-mode-prefix "\M-#"))

;;;;; paperless

(use-package! paperless
  :commands (paperless)
  :config
  (setq paperless-capture-directory "~/Nextcloud/Documents/INBOX")
  (setq paperless-root-directory "~/Nextcloud/Documents")
  (map! :after paperless
        :map paperless-mode-map
        :localleader
        "v" #'paperless-display
        "f" #'paperless-file
        "x" #'paperless-execute
        "D" #'paperless-delete
        "r" #'paperless-rename
        "s" #'paperless-scan-directories))

;;;;; projectile

(after! projectile
  (setq projectile-indexing-method 'alien)
  (setq projectile-project-search-path '("~/Source" "~/Source/Joyent" "~/Sites" "~/.local/share" "~/.config"))
  (setq projectile-ignored-projects '("~/" "/tmp" "~/.emacs.d/.local/straight/repos/"))
  (defun projectile-ignored-project-function (filepath)
    "Return t if FILEPATH is within any of `projectile-ignored-projects'"
    (or (mapcar (lambda (p) (s-starts-with-p p filepath)) projectile-ignored-projects))))

;;;;; Pop Up

(set-popup-rules! '(("^\\*helpful" :size 0.35)
                    ("^\\*Ibuffer\\*$" :size 0.35)
                    ("^\\*info.*" :size 80 :side right)
                    ("^\\*Man.*" :size 80 :side right)
                    ("^\\*keycast.*" :size 50 :side right)
                    ("^\\*Customize" :actions display-buffer)
                    ("^\\*edit-indirect" :size 0.6)
                    ("^\\*YASnippet Tables\\*$" :size 0.35)
                    ("^\\*grep\\*$" :size 0.35)
                    ("^\\*pytest\\*" :size 0.35)
                    ("^\\*Anaconda\\*$" :size 0.35)
                    ("\\*.*server log\\*$" :side top :size 0.20 :select nil)
                    ((lambda (buf _) (with-current-buffer buf (eq major-mode 'forge-topic-mode))) :size 0.35)
                    ))
;;;;; SPELL

(after! flyspell
  (setq ispell-personal-dictionary (expand-file-name "dictionary/personal" doom-private-dir))
  (setq flyspell-lazy-idle-seconds 0.5))

;;;;; systemd mode

(use-package! systemd
  :commands (systemd-mode)
  :mode "\\.service\\'"
  :config
  (map! :map systemd-mode
        :localleader
        :prefix ("h" . "help")
        "d" #'systemd-doc-directives
        "o" #'systemd-doc-open))

;;;;; TRAMP

(after! tramp
  (setenv "SHELL" "/bin/bash")
  (setq tramp-shell-prompt-pattern "\\(?:^\\|\\)[^]#$%>\n]*#?[]#$%>] *\\(�\\[[0-9;]*[a-zA-Z] *\\)*"))

;;;;; TREEMACS

(after! treemacs
  (setq +treemacs-git-mode 'extended)
  (setq treemacs-width 30))

;;;;; vimrc-mode

(use-package! vimrc-mode
  :commands vimrc-mode)
(add-to-list 'auto-mode-alist '("\\.vim\\(rc\\)?\\'" . vimrc-mode))

;;;;; vlf

(use-package! vlf-setup
  :defer-incrementally  vlf-tune vlf-base vlf-write vlf-search vlf-occur vlf-follow vlf-ediff vlf)

;;;;; wakatime

(defun marty/startwakatime ()
  "Start wakatime mode."
  (interactive)
  (setq wakatime-api-key (auth-source-pass-get 'secret "Application/wakatime/apikey"))
  (global-wakatime-mode))

(use-package! wakatime-mode
  :config
  (cond (IS-MAC (setq wakatime-cli-path "/usr/local/bin/wakatime-cli"))
        (IS-LINUX (setq wakatime-cli-path "/usr/bin/wakatime"))))

(add-hook 'doom-first-buffer-hook  #'marty/startwakatime)

;;;;; Whichkey

(setq which-key-idle-delay 1) ;; I need the help, I really do
(setq which-key-idle-secondary-delay 0.05)
(setq which-key-allow-multiple-replacements t)
(after! which-key
  (pushnew!
   which-key-replacement-alist
   '(("" . "\\`+?evil[-:]?\\(?:a-\\)?\\(.*\\)") . (nil . "◂\\1"))
   '(("\\`g s" . "\\`evilem--?motion-\\(.*\\)") . (nil . "◃\\1"))))

;; tell which-key to behave
(setq which-key-use-C-h-commands t
      prefix-help-command #'which-key-C-h-dispatch)

(defadvice! fix-which-key-dispatcher-a (fn &rest args)
  "Fix which-key Dispatcher."
  :around #'which-key-C-h-dispatch
  (let ((keys (this-command-keys-vector)))
    (if (equal (elt keys (1- (length keys))) ?\?)
        (let ((keys (which-key--this-command-keys)))
          (embark-bindings (seq-take keys (1- (length keys)))))
      (apply fn args))))

;;;;; xeft

(use-package! xeft
  :defer t
  :config
  (setq xeft-directory "~/Nextcloud/Notes/org")
  (setq xeft-database "~/.local/share/Doom/.local/cache")
  (setq xeft-recursive t)
  (map! :after xeft
        :map xeft-mode-map
        :n "C-n" #'xeft-next
        :n "C-p" #'xeft-previous
        :n "R"   #'xeft-full-reindex
        :n "c"   #'xeft-create-note
        :n "j"   #'xeft-next
        :n "k"   #'xeft-previous
        :n "r"   #'xeft-refresh))

;;;;; zeal-at-point

(use-package! zeal-at-point
  :defer t
  :bind  ("C-c z" . zeal-at-point)
  :config
  (add-to-list 'zeal-at-point-mode-alist '(python-mode . "python")))


;;;; LOAD FILES
(load! "functions.el")
(load! "org-mode.el")
(load! "mu4e.el")
(load! "abbrev.el")

;;;; CUSTOM

(when (file-directory-p custom-file)
  (message (concat "Please delete " custom-file ". And customization in config.el and +ui.el.")))

(custom-set-variables
 '(warning-suppress-log-types '((lsp-mode) (iedit)))
 '(warning-suppress-types '((iedit))))

(provide 'config)
;;; config.el ends here