emacs config

  (defvar bootstrap-version)
  (let ((bootstrap-file
         (expand-file-name "straight/repos/straight.el/bootstrap.el"
                           (or (bound-and-true-p straight-base-dir)
                               user-emacs-directory)))
        (bootstrap-version 7))
    (unless (file-exists-p bootstrap-file)
      (with-current-buffer
          (url-retrieve-synchronously
           "https://raw.githubusercontent.com/radian-software/straight.el/develop/install.el"
           'silent 'inhibit-cookies)
        (goto-char (point-max))
        (eval-print-last-sexp)))
    (load bootstrap-file nil 'nomessage))

  (straight-use-package 'use-package)
  (setq straight-use-package-by-default t)

;  (setq use-package-always-ensure t)

(server-start)
(winner-mode 1)

;; interaction
(setq use-short-answers t) ;; when emacs asks for 'yes' or 'no', let 'y' or 'n' suffice
(setq confirm-kill-emacs 'yes-or-no-p) ;;confirm to quit
(setq initial-major-mode 'org-mode ;; major mode of new buffers
      initial-scratch-message "")

;; window
(setq frame-resize-pixelwise t)
(setq ns-pop-up-frames nil)
(setq window-resize-pixelwise nil)
(setq split-width-threshold 80)
(setq lik-default-line-spacing 2)


      (defun lik/org-setup ()
        (org-indent-mode) ;;keeps org items like text under headings, lists, nicely indented 
        (visual-line-mode 1) ;; nice line wrapping
    ;    (centered-cursor-mode 1) ;; enable centered cursor mode
        (smartparens-mode 0) ;; disable smartparens
;        (hl-prog-extra-mode) ;; highlighting with regexps
        (setq-local line-spacing (+ lik-default-line-spacing 2)) ;; a bit more line spacing for org mode
        (valign-mode)
        )



      (defun lik/prettify-symbols-setup ()
      ;; checkboxes
      (push '("[ ]" .  "\u2610") prettify-symbols-alist)
      (push '("[X]" . "\u2611" ) prettify-symbols-alist)
      ;; (push '("[X]" . "\u2612" ) prettify-symbols-alist)
      (push '("[-]" . "\u274d" ) prettify-symbols-alist)

      ;; org-babel
      (push '("#+BEGIN_SRC" . ?\u226b) prettify-symbols-alist)
      (push '("#+END_SRC" . ?\u226b) prettify-symbols-alist)
      (push '("#+begin_src" . ?\u226b) prettify-symbols-alist)
      (push '("#+end_src" . ?\u226b) prettify-symbols-alist)

      (push '("#+BEGIN_QUOTE" . ?\u275d) prettify-symbols-alist)
      (push '("#+END_QUOTE" . ?\u275e) prettify-symbols-alist)

      ;; (push '("#+BEGIN_SRC python" . \ue928) prettify-symbols-alist) ;; This is the Python symbol. Comes up weird for some reason
      (push '("#+RESULTS:" . ?\u225a ) prettify-symbols-alist)

      ;; drawers
      (push '(":PROPERTIES:" . ?\uf1de) prettify-symbols-alist)

      ;; tags
      ;; (push '(":Misc:" . "\ue2c8" ) prettify-symbols-alist)

      (prettify-symbols-mode))

      (use-package ob-nix
              :ensure t
              :defer 0
              :config
              (require 'ob-nix))


      (use-package org
        :hook (org-mode . lik/org-setup)
        :hook (org-mode . lik/prettify-symbols-setup)
        :hook (org-capture-mode . evil-insert-state) ;; start org-capture in insert state by default
        :diminish org-indent-mode
        :diminish visual-line-mode
        :config
        (setq org-directory "~/Documents/orgfiles")
        (setq org-agenda-files
              '("tasks.org"
                "birthdays.org"
                "social_media_planning.org"
                "~/org_mode_exp/example-file.org"
                "~/Documents/wizr/work_master.org"))
        (setq org-agenda-start-with-log-mode t)
        (setq org-log-done 'time)
        (setq org-log-into-drawer t)
        (setq org-startup-with-inline-images t)
        (setq org-src-fontify-natively t)
        (setq org-highlight-latex-and-related '(native)); highlight inline latex
        (setq org-startup-folded 'showeverything)
        (setq org-image-actual-width 300)
        (setq org-fontify-whole-heading-line t)
        (setq org-pretty-entities t)
        (setq org-cycle-separator-lines 1)
        (setq org-catch-invisible-edits 'show-and-error) ;; 'smart
        (setq org-src-tab-acts-natively t)

        ;; M-Ret can split lines on items and tables but not headlines and not on anything else (unconfigured)
        (setq org-M-RET-may-split-line '((headline) (item . t) (table . t) (default)))
        (setq org-loop-over-headlines-in-active-region nil)

        ;; Opens links to other org file in same frame (rather than splitting)
        (setq org-link-frame-setup '((file . find-file)))

        (setq org-log-done t
          org-log-into-drawer t)

    ;; Automatically change bullet type when indenting
    ;; Ex: indenting a + makes the bullet a *.
        (setq org-list-demote-modify-bullet
          '(("+" . "*") ("*" . "-") ("-" . "+")))
        ;; Automatically save and close the org files I most frequently archive to.
  ;; I see no need to keep them open and crowding my buffer list.
  ;; Uses my own function jib/save-and-close-this-buffer.
        (dolist (file '("/home/lik/Documents/orgfiles/archive.org"))

          (advice-add 'org-archive-subtree-default :after 
                (lambda () (lik/save-and-close-this-buffer file)))))




;; lines
(setq truncate-lines t)
(setq-default tab-width 4)
(setq-default fill-column 80)
(setq line-mode-visual t);; C-p, C-n, etc uses visual lines

(use-package paren
  ;; highlight matching delimiters
  :straight nil
  :config
  (setq show-paren-delay 0.1
        show-paren-highlight-openparen t
        show-paren-when-point-inside-paren t
        show-paren-when-point-in-periphery t)
  (show-paren-mode 1))

(setq sentence-end-double-space nil) ;; sentences end with one space
(setq bookmark-set-fringe-mark nil)

;; scrolling
(setq scroll-conservatively 101)
(setq
 mouse-wheel-follow-mouse 't
 mouse-wheel-progressive-speed nil
 ;; the most important setting of all! make each scroll-event move 2 lines at
 ;; a time (instead of 5 at default). simply hold down shift to move twice
 ;; fast, or hold down control to move 3x as fast. perfect for trackpads
 mouse-wheel-scroll-amount '(1 ((shift) . 3) ((control) . 6)))
(setq visible-bell nil)
(setq ring-bell-function 'ignore)


;; try really hard to keep the cursor from getting stuck in the read-only prompt
;; portion of the minibuffer
(setq minibuffer-prompt-properties '(read-only t intangible t cursor-intangible t face minibuffer-prompt))
(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)

;; explicitly define a width to reduce the cost of on-the-fly computation

(setq-default display-line-numbers-width 3)

;; when opening a symlink that links to a file in a git repo, edit the file
;; in the git repo so we can use the emacs vc features (like diff) in the future
(setq vc-follow-symlinks t)

;; backups/lockfiles
;; don't generate backups or lockfiles
(setq create-lockfiles nil
      make-backup-files nil
      ;; but in case the user does enable it, some sensible defaults
      version-control t
      backup-by-copying t
      delete-old-versions t
      kept-old-versions 5
      kept-new-versions 5
      backup-directory-alist (list (cons "." (concat user-emacs-directory "backup/"))))

(use-package recentf
  :straight nil
  :config
  (setq ;;recentf-auto-cleanup 'never
   ;; recentf-max-menu-items 0
   recentf-max-saved-items 200)
  (setq recentf-filename-handlers ;; show home folder path as a ~
        (append '(abbreviate-file-name) recentf-filename-handlers))
  (recentf-mode))

(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)

;; encoding
(when (fboundp 'set-charset-priority)
  (set-charset-priority 'unicode))
(prefer-coding-system 'utf-8)
(setq locale-coding-system 'utf-8)

(setq blink-cursor-interval 0.6)
(blink-cursor-mode 0)

(setq save-interprogram-paste-before-kill t
      apropos-do-all t
      mouse-yank-at-point t)

(setq what-cursor-show-names t) ;; improves C-x
(setq dired-kill-when-opening-new-dired-buffer t)
(setq reb-re-syntax 'string) ;; https://www.masteringemacs.org/article/re-builder-interactive-regexp-builder

      (tool-bar-mode -1)
      (defvar emacs/default-font-size 240)
      (add-to-list 'default-frame-alist '(font . "Agave Nerd Font Mono-24"))
      (menu-bar-mode -1)
      (tooltip-mode -1)
      (set-fringe-mode 10)
      (column-number-mode)
      (global-display-line-numbers-mode t)
      (dolist (mode '(org-mode-hook
                      term-mode-hook
                      eshell-mode-hook
;                      treemacs-mode-hook
                      shell-mode-hook))
        (add-hook mode (lambda () (display-line-numbers-mode 0))))
      (setq package-archives '(("melpa" . "https://melpa.org/packages/")
                               ("org" . "https://orgmode.org/elpa/")
                               ("elpa" . "https://elpa.gnu.org/packages/")))
;      (require 'package)
;      (package-initialize)
;      (setq my-packages
;            '(ivy
;              counsel
;              json-mode
;              projectile
;              cider
;              clojure-mode
;              expand-region
;              jinja2-mode
;              magit
;              markdown-mode
;              paredit
;              wrap-region
;              yaml-mode
  ;         elpy
;              json-mode
;              doom-themes
;              modus-themes
;              all-the-icons
;              all-the-icons-dired
;              which-key
;              ivy-rich
;              helpful
;              rainbow-delimiters
;              evil
;              evil-collection
;              forge
;              evil-nerd-commenter
;              projectile
;              counsel-projectile
;    ;          dap-mode
;              typescript-mode
;              company
;              company-box
;              term
;              eterm-256color
;              vterm
;              eshell-git-prompt
;              eshell
;              apheleia
;              pet
;              lsp-ui
;              doom-modeline
;              org
;              org-bullets
;              nix-mode
;              olivetti
;              visual-fill-column
;              page-break-lines
;              nerd-icons
;              ripgrep
;              consult
;              orderless
;              marginalia
;              embark
;              prettier
;              prettier-js
 ;             prettier-rc
 ;             js2-mode
 ;             org-edna
;              treemacs
;              treemacs-evil
;              treemacs-icons-dired
;              treemacs-magit
;              treemacs-persp
;              treemacs-tab-bar
;              treemacs-projectile))
 ;     (dolist (pkg my-packages)
 ;       (unless (package-installed-p pkg)
 ;         (package-install pkg)))
 ;     (unless package-archive-contents
 ;       (package-refresh-contents))
  ;    (unless (package-installed-p 'use-package)
  ;      (package-install 'use-package))
;  (require 'use-package)
;  (setq use-package-verbose nil)
  (setq standard-indent 2)

  (defun lik/get-project-root ()
    (when (fboundp 'projectile-project-root)
      (projectile-project-root)))

  (global-set-key (kbd "<escape>") 'keyboard-escape-quit)

  (setq history-length 25)
  (setq savehist-autosave-interval 600)
  (setq history-delete-duplicates t)
  (global-auto-revert-mode 1)

(use-package gcmh
  :diminish gcmh-mode
  :config
  (setq gcmh-idle-delay 5
        gcmh-high-cons-threshold (* 16 1024 1024)) ;16mb
  (gcmh-mode 1))

(add-hook 'emacs-startup-hook
          (lambda ()
            (setq gc-cons-percentage 0.1))) ; default value for gc-cons-percentage

(setq register-preview-delay 0);; show registers asap
(setq org-directory (concat "/home/lik/Documents/" "orgfiles/"))
(set-register ?i (cons 'file (concat org-directory "/home/lik/.dotfiles/config.org")))
(set-register ?w (cons 'file (concat org-directory "/home/lik/Documents/wizr/work_master.org")))

(setq browse-url-firefox-program "/run/current-system/sw/bin/firefox")
(setq browse-url-chrome-program "/run/current-system/sw/bin/chromium")

(defun lik/rg ()
  "allows you to select a folder to ripgrep"
  (interactive)
  (let ((current-prefix-arg 4)) ;;emulate C-u
    (call-interactively 'counsel-rg)))

(defun lik/fzf ()
  "allows you to select a folder to fzf"
  (interactive)
  (let ((current-prefix-arg '-)) ;;emulate C-u
    (call-interactively 'counsel-fzf)))
;; https://emacsredux.com/blog/2013/03/28/google/
(defun lik/er-google ()
  "google the selected region if any, display a query prompt otherwise"
  (interactive)
  (browse-url
   (concat
    "http://www.google.com/search?ie=utf-8&oe=utf-8&q="
    (url-hexify-string (if mark-active
                           (buffer-substring (region-beginning) (region-end))
                         (read-string "google: "))))))

(defun lik/switch-to-scratch-buffer ()
  (interactive)
  (switch-to-buffer "*scratch*"))

(defun lik/kill-other-buffers (&optional arg)
  "kill all other buffers
  if the universal prefix argument is used then will kill the windows too"
  (interactive "P")
  (when (yes-or-no-p (format "killing all buffers except \"%s\"? "
                             (buffer-name)))
    (mapc 'kill-buffer (delq (current-buffer) (buffer-list)))
    (when (equal '(4) arg) (delete-other-windows))
    (message "buffers deleted")))

(defun spacemacs/new-wmpty-buffer ()
  "create a new buffer called untitled (<n>)"
  (interactive)
  (let ((newbuf (generate-new-buffer-name "*scratch*")))
    (switch-to-buffer newbuf)))

(defun lik/listify (&optional count)
"Turn the region's (or count = n lines) into an orgmode list by prepending a +."
(interactive "p")
(let ((lines (count-lines (region-beginning) (region-end)))) ;; By default grab a region
  (if (> count 1) (setq lines count)) ;; but if there was an argument, override the # of lines
  (save-excursion
    (if (use-region-p) ;; If there's a region go to the start and deactivate the region
        (goto-char (region-beginning)) (deactivate-mark))
    (while (> lines 0) ;; Add "+ " at the beginning of each line
      (beginning-of-line)
      (insert "+ ")
      (forward-line)
      (setq lines (1- lines))))))

  (fset 'lik|sublistify
        (kmacro-lambda-form [?A M-return tab S-right escape ?j ?0] 0 "%d"))

(defun lik/copy-whole-buffer-to-clipboard ()
"Copy entire buffer to clipboard"
(interactive)
(save-excursion
  (mark-whole-buffer)
  (simpleclip-copy (point-min) (point-max))
  (deactivate-mark))
(message "Copied entire buffer to clipboard"))

(defun lik/toggle-maximize-buffer ()
  "maximize buffer"
  (interactive)
  (if (and (= 1 (length (window-list)))
           (assoc ?_ register-alist))
      (jump-to-register ?_)
    (progn
      (window-configuration-to-register ?_)
      (delete-other-windows))))

(defun lik/split-window-vertically-and-switch ()
  (interactive)
  (split-window-vertically)
  (other-window 1))

(defun lik/split-window-horizontally-and-switch ()
  (interactive)
  (split-window-horizontally)
  (other-window 1))

(defun lik/load-theme (theme)
  "enhance 'load-theme' by first disabling enabled themes"
  (mapc #'disable-theme custom-enabled-themes)
  (load-theme theme t))



(use-package general
  :config
  (general-create-definer rune/leader-keys
    :keymaps '(normal insert visual emacs)
    :prefix "SPC"
    :global-prefix "C-SPC")


    (rune/leader-keys
     "t" '(:ignore t :which-key "toggles")
    "tt" '(counsel-load-theme :which-key "choose theme")))

(use-package ivy
  :demand t
  :diminish ivy-mode
  :config
  (setq ivy-extra-directories nil) ;; Hides . and .. directories
  (setq ivy-initial-inputs-alist nil) ;; Removes the ^ in ivy searches
  (setq ivy-re-builders-alist '((t . ivy--regex-ignore-order)))
  (setq ivy-height 12)
  (setq ivy-fixed-height-minibuffer t)
  (setq ivy-use-virtual-buffers t)
  (setq ivy-use-selectable-prompt t)
  (setq counsel-find-file-at-point t)
  (setq ivy-count-format "(%d%d) ")

  (add-to-list 'ivy-height-alist '(counsel-M-x . 7)) ;; Don't need so many lines for M-x, I usually know what command I want

  (ivy-mode 1)

  ;; Shows a preview of the face in counsel-describe-face
  (add-to-list 'ivy-format-functions-alist '(counsel-describe-face . counsel--faces-format-function))

  :general
  (general-define-key
   ;; Also put in ivy-switch-buffer-map b/c otherwise switch buffer map overrides and C-k kills buffers
   :keymaps '(ivy-minibuffer-map ivy-switch-buffer-map)
   "S-SPC" 'nil
   "C-SPC" 'ivy-restrict-to-matches ;; Default is S-SPC, changed this b/c sometimes I accidentally hit S-SPC
   ;; C-j and C-k to move up/down in Ivy
   "C-k" 'ivy-previous-line
   "C-j" 'ivy-next-line)
  )

;; Nice icons in Ivy. Replaces all-the-icons-ivy.
(use-package all-the-icons-ivy-rich
  :init (all-the-icons-ivy-rich-mode 1)
  :config
  (setq all-the-icons-ivy-rich-icon-size 1.0))

(use-package ivy-rich
  :after ivy counsel
  :init
  (setq ivy-rich-path-style 'abbrev)
  (setcdr (assq t ivy-format-functions-alist) #'ivy-format-function-line)
  :config
  (ivy-rich-mode 1))

  (setq display-time-default-load-average nil)
  (line-number-mode)
  (column-number-mode)
  (display-time-mode -1)

  (use-package hide-mode-line
    :commands (hide-mode-line-mode))

;   (use-package doom-modeline
;     
;     :init (doom-modeline-mode 1)
;     :custom ((doom-modeline-height 15)))

(use-package doom-modeline
  :config
  (doom-modeline-mode)
  (setq doom-modeline-buffer-file-name-style 'relative-from-project
        doom-modeline-enable-word-count nil
        doom-modeline-buffer-encoding nil
        doom-modeline-icon t
        doom-modeline-modal-icon t
        doom-modeline-major-mode-icon t
        doom-modeline-major-mode-color-icon nil
        doom-modeline-buffer-state-icon nil
        doom-modeline-bar-width 3
        doom-modeline-height 15))

(setq frame-inhibit-implied-resize t)
(add-to-list 'default-frame-alist '(tool-bar-lines . 0))
(add-to-list 'default-frame-alist '(menu-bar-lines . 0))
(add-to-list 'default-frame-alist '(vertical-scroll-bars))
(add-to-list 'default-frame-alist '(ns-transparent-titlebar . t))

    (use-package all-the-icons
      :if (display-graphic-p)
      :commands all-the-icons-install-fonts
      :init
      (unless (find-font (font-spec :name "all-the-icons"))
        (all-the-icons-install-fonts t)))
    (use-package all-the-icons-dired
      :if (display-graphic-p)
      :hook (dired-mode . all-the-icons-dired-mode))
    (use-package doom-themes
      :after mixed-pitch
      :init (load-theme 'doom-tomorrow-night t)
      :config
      (doom-themes-visual-bell-config)
       (doom-themes-org-config)
       :custom-face
       (org-ellipsis ((t (:height 0.8 :inherit 'shadow))))
       (org-scheduled-previously ((t (:background "red")))))

    (use-package kaolin-themes
      :config
      (setq kaolin-themes-modeline-border nil))
      ;; disable underline for org deadline warnings
;      (org-warning ((t (:underline nil))))
      ;; darkens the org-ellipses (first unset the color, then give it shadow)
;      (org-ellipsis ((t (:foreground unspecified :height 0.8 :inherit 'shadow)))))

    (use-package modus-themes
      :init
      (setq modus-themes-italic-constructs nil
            modus-themes-bold-constructs t
            modus-themes-region '(bg-only no-extend)
            modus-themes-hl-line '(intense) ;;accented or intense
            modus-themes-syntax '(yellow-comments)
            modus-themes-org-blocks 'gray-background
            modus-themes-mode-line '(moody borderless)) ;; mody or accented

    (setq modus-themes-headings
          (quote ((1 . (variable-pitch 1.1 rainbow))
                  (2 . (regular))
                  (3 . (regular))
                  (4 . (regular))
                  (t . (rainbow))
                  )))
 ;   (modus-themes-load-themes)
    :custom-face
    (org-ellipsis ((t (:height 0.8 :inherit 'shadow)))))



    (use-package ef-themes
      :init
      (setq ef-themes-headings
            (quote ((1 . (variable-pitch 1.1))
                    (2 . (regular))
                    (3 . (regular))
                    (4 . (regular)))))
      :custom-face
      (org-scheduled-today ((t (:inherit org-level-3)))))

    ;; loading theme based on the time

(setq-default fringes-outside-margins nil)
(setq-default indicate-buffer-boundaries nil) ;;otherwise shows a corner icon on the edge
(setq-default indicate-empty-lines nil) ;;otherwise there are weird fringes on blank lines
(set-face-attribute 'fringe nil :background nil)
(set-face-attribute 'header-line nil :background nil :inherit 'default)
(add-hook 'prog-mode-hook 'hl-line-mode)
(add-hook 'prog-mode-hook 'display-line-numbers-mode)

(use-package visual-fill-column
  :defer t
  :config
  (setq visual-fill-column-center-text t)
  (setq visual-fill-column-width 100)
  (setq visual-fill-column-center-text t))

(use-package writeroom-mode
  :defer t
  :config
  (setq writeroom-maximize-window nil
        writeroom-mode-line t
        writeroom-global-effects nil
        writeroom-extra-line-spacing 3)
  (setq writeroom-width visual-fill-column-width))

(use-package which-key
  :init
  (which-key-mode)
  (which-key-setup-minibuffer)
  :diminish which-key-mode
  :config
  (setq which-key-idle-delay 1)
  (setq which-key-prefix-prefix "◉ ")
  (setq which-key-sort-order 'which-key-key-order-alpha
        which-key-min-display-lines 3
        which-key-max-display-columns nil))

(defvar lik/home (concat (getenv "HOME") "/") "my home directory")

   (use-package counsel
       :bind (
                      ("C-x C-b" . ivy-switch-buffer)
                      ("C-x b" . ivy-switch-buffer)
                      ("M-r" . counsel-ag)
                      ("C-x C-d" . counsel-dired)
                      ("C-x d" . counsel-dired)
                      )
       :diminish
    :config
    (setq default-directory lik/home)
    (setq counsel-switch-buffer-preview-virtual-buffers nil) ;; Removes recentfiles/bookmarks from counsel-switch-buffer
    (setq counsel-find-file-ignore-regexp
          (concat
           ;; That weird Icon? file in Dropbox.
           "\\(Icon\
  \\)"
           ;; Hides file names beginning with # or .
           "\\|\\(?:\\`[#.]\\)"))

    ;; emacs regexp notes: had to put \\| before the second regexp to make this work

    ;; Sorts counsel-recentf in order of time last accessed
    (add-to-list 'ivy-sort-functions-alist
                 '(counsel-recentf . file-newer-than-file-p))

    (add-to-list 'recentf-exclude
                 (expand-file-name "projectile-bookmarks.eld" user-emacs-directory))

    ;; Use fd
    (setq find-program "fd")
    (setq counsel-file-jump-args (split-string "-L --type f -H")) ;; follow symlinks, files, show hidden
      (global-set-key [remap org-set-tags-command] #'counsel-org-tag)

    :general
    (general-define-key :keymaps 'counsel-find-file-map
                        "C-c f" 'counsel-file-jump-from-find) ;; when in counsel-find-file, run this to search the whole directory recursively
    )
(use-package swiper
  :bind(("M-C-s" . swiper)))

(use-package ivy-hydra)

  (use-package prescient
  :config
  (setq-default history-length 1000)
  (setq-default prescient-history-length 1000) ;; More prescient history
  (prescient-persist-mode +1))

;; Use `prescient' for Ivy menus.
(use-package ivy-prescient
  :after ivy
  :config
  ;; don't prescient sort these commands
  (dolist (command '(org-ql-view counsel-find-file fontaine-set-preset))
    (setq ivy-prescient-sort-commands (append ivy-prescient-sort-commands (list command))))
  (ivy-prescient-mode +1))

;; (use-package company-prescient
;;   :defer 2
;;   :after company
;;   :config
;;   (company-prescient-mode +1))

(use-package smartparens
  :ensure t
:diminish smartparens-mode
:defer 1
:config
(progn
  (require 'smartparens-config)
  (smartparens-global-mode 1)
  (show-paren-mode t))
;; Load default smartparens rules for various languages
(require 'smartparens-config)
(setq sp-max-prefix-length 25)
(setq sp-max-pair-length 4)
(setq sp-highlight-pair-overlay nil
      sp-highlight-wrap-overlay nil
      sp-highlight-wrap-tag-overlay nil)

(with-eval-after-load 'evil
  (setq sp-show-pair-from-inside t)
  (setq sp-cancel-autoskip-on-backward-movement nil)
  (setq sp-pair-overlay-keymap (make-sparse-keymap)))

(let ((unless-list '(sp-point-before-word-p
                     sp-point-after-word-p
                     sp-point-before-same-p)))
  (sp-pair "'"  nil :unless unless-list)
  (sp-pair "\"" nil :unless unless-list))

;; In lisps ( should open a new form if before another parenthesis
(sp-local-pair sp-lisp-modes "(" ")" :unless '(:rem sp-point-before-same-p))

;; Don't do square-bracket space-expansion where it doesn't make sense to
(sp-local-pair '(emacs-lisp-mode org-mode markdown-mode gfm-mode)
               "[" nil :post-handlers '(:rem ("| " "SPC")))


(dolist (brace '("(" "{" "["))
  (sp-pair brace nil
           :post-handlers '(("||\n[i]" "RET") ("| " "SPC"))
           ;; Don't autopair opening braces if before a word character or
           ;; other opening brace. The rationale: it interferes with manual
           ;; balancing of braces, and is odd form to have s-exps with no
           ;; whitespace in between, e.g. ()()(). Insert whitespace if
           ;; genuinely want to start a new form in the middle of a word.
           :unless '(sp-point-before-word-p sp-point-before-same-p)))
(smartparens-global-mode t))

(use-package mixed-pitch
  :defer t
  :config
  (setq mixed-pitch-set-height nil)
  (dolist (face '(org-date org-priority org-tag org-special-keyword))
    (add-to-list 'mixed-pitch-fixed-pitch-faces face)))

(use-package evil-anzu :defer t)

(use-package avy
  :defer t
  :config
  (setq avy-case-fold-search nil))

(use-package simpleclip :config (simpleclip-mode 1))
;; allows pasting in minibuffer with M-v
(defun lik/paste-in-minibuffer ()
  (local-set-key (kbd "M-v") 'simpleclip-paste))
(add-hook 'minibuffer-setup-hook 'lik/paste-in-minibuffer)

(use-package undo-fu)

  (use-package super-save
  :diminish super-save-mode
  :defer 2
  :config
  (setq super-save-auto-save-when-idle t
        super-save-idle-duration 5 ;; after 5 seconds of not typing autosave
        super-save-triggers ;; Functions after which buffers are saved (switching window, for example)
        '(evil-window-next evil-window-prev balance-windows other-window next-buffer previous-buffer)
        super-save-max-buffer-size 10000000)
  (super-save-mode +1))

;; After super-save autosaves, wait __ seconds and then clear the buffer. I don't like
;; the save message just sitting in the echo area.
(defun lik-clear-echo-area-timer ()
  (run-at-time "2 sec" nil (lambda () (message " "))))
(advice-add 'super-save-command :after 'lik-clear-echo-area-timer)

(use-package saveplace
  :init (setq save-place-limit 100)
  :config (save-place-mode))

  (defvar lik/emacs-stuff "/home/lik/Documents/" "directory where personal emacs files are kept")

  (use-package yasnippet
  :diminish yas-minor-mode
  :defer 5
  :config
  (setq yas-snippet-dirs (list (expand-file-name "snippets" lik/emacs-stuff)))
  (yas-global-mode 1)) ;; or M-x yas-reload-all if you've started YASnippet already.

;; Silences the warning when running a snippet with backticks (runs a command in the snippet)
(require 'warnings)
(add-to-list 'warning-suppress-types '(yasnippet backquote-change)) 

(use-package helpful
  :custom
  (counsel-describe-function-function #'helpful-callable)
  (counsel-describe-variable-function #'helpful-variable)
  :bind
  ([remap describe-function] . counsel-describe-function)
  ([remap describe-command] . helpful-command)
  ([remap describe-variable] . counsel-describe-variable)
  ([remap describe-key] . helpful-key))

  (use-package rainbow-delimiters
    :hook (prog-mode . rainbow-delimiters-mode))
  (global-set-key (kbd "C-M-j") 'counsel-switch-buffer)
;  (global-set-key (kbd "C-M-k") 'dw/switch-to-browser-buffer)

  (global-set-key (kbd "C-x C-f") 'counsel-find-file)
  (global-set-key (kbd "C-x C-z") 'counsel-fzf)

(use-package dired
  :straight nil
  :commands (dired dired-find-file)
  :bind (("C-x C-j" . dired-find-file))
  :custom ((dired-listing-switches "-agho --group-directories-first")))

(use-package dired-single
  :commands (dired dired-jump))

(use-package dired-open
  :commands (dired dired-jump)
  :config
  (setq dired-open-extensions '(("png" . "feh")
                                ("mkv" . "mpv"))))
(use-package dired-hide-dotfiles
  :hook (dired-mode . dired-hide-dotfiles-mode)
  :config
  (evil-collection-define-key 'normal 'dired-mode-map
                              "H" 'dired-hide-dotfiles-mode))
(setq gc-cons-threshold (* 2 1000 1000))

  (setq gc-cons-threshold 100000000)
  (setq read-process-output-max (* 1024 1024))
  (use-package lsp-mode
    :hook ((python-mode js-mode) . lsp-deferred)
    :commands lsp
    :config
      (setq lsp-ui-doc-enable nil)
      (setq lsp-ui-doc-show-with-cursor nil)
      (setq lsp-ui-doc-show-with-mouse nil)
      (setq lsp-lens-enable nil)
      (setq lsp-headerline-breadcrumb-enable t)
      (setq lsp-ui-sideline-enable nil)
      (setq lsp-ui-sideline-show-code-actions nil)
      (setq lsp-ui-sideline-enable nil)
      (setq lsp-ui-sideline-show-hover nil)
      (setq lsp-modeline-code-actions-enable nil)
      (setq lsp-diagnostics-provider :none)
      (setq lsp-ui-sideline-enable nil)
      (setq lsp-ui-sideline-show-diagnostics nil)
      (setq lsp-eldoc-enable-hover nil)
      (setq lsp-modeline-diagnostics-enable nil)
      (setq lsp-signature-auto-activate nil)
      (setq lsp-signature-render-documentation nil)
      (setq lsp-completion-provider :none)
      (setq lsp-completion-show-detail nil)
      (setq lsp-completion-show-kind nil)
      )

;  (use-package lsp-ui
;    :commands lsp-ui-mode
;    :config
;    (setq lsp-ui-doc-enable nil)
;    (setq lsp-ui-doc-header t)
;    (setq lsp-ui-doc-include-signature t)
;    (setq lsp-ui-doc-border (face-foreground 'default))
;    (setq lsp-ui-sideline-show-code-actions t)
;    (setq lsp-ui-sideline-delay 0.005))

;  (use-package lsp-pyright
;    :hook (python-mode . (lambda () (require 'lsp-pyright)))
;    :init (when (executable-find "python")
;            (setq lsp-pyright-python-executable-cmd "python")))

(use-package evil
  :init
  (setq evil-want-integration t)
  (setq evil-want-keybinding nil)
  (setq evil-want-C-u-scroll t)
  (setq evil-want-C-i-jump nil)
  (setq evil-want-fine-undo t)
  (setq evil-want-Y-yank-to-eol t)
  :config
  (evil-set-initial-state 'dashboard-mode 'motion)
  (evil-set-initial-state 'debugger-mode 'motion)
  (evil-set-initial-state 'pdf-view-mode 'motion)
  (evil-set-initial-state 'buffer-list-mode 'emacs)
  (evil-set-initial-state 'inferior-python-mode 'emacs)
  (evil-set-initial-state 'term-mode 'emacs)
  (evil-set-initial-state 'calc-mode 'emacs)
  (define-key evil-insert-state-map (kbd "C-b")  'evil-normal-state)
  (define-key evil-insert-state-map (kbd "C-h") 'evil-delete-backward-char-and-join)

  (define-key evil-window-map "\C-q" 'evil-delete-buffer) ;;maps C-w C-q to evil-delete-buffer (the first C-w puts you into evil-window-map)
  (define-key evil-window-map "\C-w" 'kill-this-buffer)
  (define-key evil-motion-state-map "\C-b" 'evil-scroll-up) ;;makes C-b how C-u is
  (define-key evil-motion-state-map [?\s-\\] 'evil-execute-in-emacs-state) ;; super-\ by default it's just \

  (evil-global-set-key 'motion "j" 'evil-next-visual-line)
  (evil-global-set-key 'motion "k" 'evil-previous-visual-line)
  (evil-set-initial-state 'messages-buffer-mode 'normal)
  (evil-set-initial-state 'dashboard-mode 'normal)

  (setq evil-emacs-state-cursor '("#649bce" box))
  (setq evil-normal-state-cursor '("#d9a871" box))

  (setq evil-visual-state-cursor '("#677691" box))
  (setq evil-insert-state-cursor '("#eb998b" (bar . 2)))
  (setq evil-replace-state-cursor '("#eb998b" hbar))
  (setq evil-motion-state-cursor '("#ad8beb" box))
  (evil-mode 1))


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


(use-package evil-collection
  :after evil
  :init
  (evil-collection-init))

(evil-define-key 'motion help-mode-map "q" 'kill-this-buffer)
(evil-define-key 'motion calendar-mode-map "q" 'kill-this-buffer)

(use-package magit

  :commands (magit-status magit-get-current-branch)
  :custom
  (magit-display-buffer-function #'magit-display-buffer-same-window-except-diff-v1))
(global-set-key (kbd "C-M-;") 'magit-status)

(use-package forge
  :after magit)

(use-package evil-nerd-commenter
  :bind ("M-/" . evilnc-comment-or-uncomment-lines))

(use-package projectile
  :diminish projectile-mode
  :config (projectile-mode)
  :custom ((projectile-completion-system 'ivy))
  :bind ("C-M-p" . projectile-find-file)
  :bind-keymap
  ("C-c p" . projectile-command-map)
  :init
  (when (file-directory-p "~/Documents")
    (setq projectile-project-search-path '("~/Documents")))
  (setq projectile-switch-project-action #'projectile-dired))

(use-package counsel-projectile
  :disabled
  :after projectile
  :config (counsel-projectile-mode))

      (use-package hydra :defer t)

      (defhydra hydra-text-scale (:timeout 4)
        "scale text"
        ("j" text-scale-increase "in")
        ("k" text-scale-decrease "out")
        ("f" nil "finished" :exit t))

      (rune/leader-keys
        "ts" '(hydra-text-scale/body :which-key "scale text"))

      (defhydra lik-hydra-variable-fonts (:pre (mixed-pitch-mode 0)
                                             :post (mixed-pitch-mode 1))
        ("t" (set-face-attribute 'variable-pitch nil :family "Times New Roman" :height 160) "Times New Roman")
        ("g" (set-face-attribute 'variable-pitch nil :family "EB Garamond" :height 160 :weight 'normal) "EB Garamond")
        ("n" (set-face-attribute 'variable-pitch nil :slant 'normal :weight 'normal :height 160 Lwidth 'normal :foundry "nil" :family "Nunito") "Nunito")
      )

      (defhydra lik-hydra-theme-switcher (:hint nil)
      "
         Dark                ^Light^
    ----------------------------------------------
    _1_ one              _z_ one-light 
    _2_ vivendi          _x_ operandi
    _3_ molokai          _c_ lik-plain
    _4_ snazzy           _v_ flatwhite
    _5_ old-hope         _b_ tomorrow-day
    _6_ henna                ^
    _7_ kaolin-galaxy        ^
    _8_ peacock              ^
    _9_ lik-plain-dark      ^
    _0_ monokai-machine      ^
    _-_ xcode                ^
    _q_ quit                 ^
    ^                        ^
    "
    ;; Dark
      ("1" (lik/load-theme 'doom-one)                            "one")
      ("2" (lik/load-theme 'modus-vivendi)                       "modus-vivendi")
      ("3" (lik/load-theme 'doom-molokai)                        "molokai")
      ("4" (lik/load-theme 'doom-snazzy)                         "snazzy")
      ("5" (lik/load-theme 'doom-old-hope)                       "old-hope")
      ("6" (lik/load-theme 'doom-henna)                          "henna")
      ("7" (lik/load-theme 'kaolin-galaxy)                       "kaolin-galaxy")
      ("8" (lik/load-theme 'doom-peacock)                        "peacock")
      ("9" (lik/load-theme 'jake-doom-plain-dark)        "jake-plain-dark")
      ("0" (lik/load-theme 'doom-monokai-machine)        "monokai-machine")
      ("-" (lik/load-theme 'doom-xcode)                          "xcode")

      ;; Light
      ("z" (lik/load-theme 'doom-one-light)                      "one-light")
      ("x" (lik/load-theme 'modus-operandi)                      "modus-operandi")
      ("c" (lik/load-theme 'jake-doom-plain)             "jake-plain")
      ("v" (lik/load-theme 'doom-flatwhite)                      "flatwhite")
      ("b" (lik/load-theme 'doom-opera-light)            "tomorrow-day")
      ("q" nil))


    ;; all-in-one window management. makes use of some custom functions
    ;; 'ace-window' (for swapping), 'windmove' (could probably be replaced
    ;; by evil?) and 'windresize'
    ;; inspired by https://github.com/jmercouris/configuration/blob/master/.emacs.d/hydra.el#L86
    (defhydra lik-hydra-window (:hint nil)
        "
  Movement      ^Split^            ^Switch^        ^Resize^
  ----------------------------------------------------------------
  _M-<left>_  <   _/_ vertical      _b_uffer        _<left>_  <
  _M-<right>_ >   _-_ horizontal    _f_ind file     _<down>_  ↓
  _M-<up>_    ↑   _m_aximize        _s_wap          _<up>_    ↑
  _M-<down>_  ↓   _c_lose           _[_backward     _<right>_ >
  _q_uit          _e_qualize        _]_forward     ^
  ^               ^               _K_ill         ^
  ^               ^                  ^             ^
  "


  ;; Movement
   ("M-<left>" windmove-left)
   ("M-<down>" windmove-down)
   ("M-<up>" windmove-up)
   ("M-<right>" windmove-right)

   ;; Split/manage
   ("-" lik/split-window-vertically-and-switch)
   ("/" lik/split-window-horizontally-and-switch)
   ("c" evil-window-delete)
   ("d" evil-window-delete)
   ("m" delete-other-windows)
   ("e" balance-windows)

   ;; Switch
   ("b" counsel-switch-buffer)
   ("f" counsel-find-file)
   ("P" project-find-file)
   ("s" ace-swap-window)
   ("[" previous-buffer)
   ("]" next-buffer)
   ("K" kill-this-buffer)

   ;; Resize
   ("<left>" windresize-left)
   ("<right>" windresize-right)
   ("<down>" windresize-down)
   ("<up>" windresize-up)

   ("q" nil))

(defhydra lik-hydra-org-table ()
  "
_c_ insert col    _v_ delete col    Move col: _h_, _l_
_r_ insert row    _d_ delete row    Move row: _j_, _k_
_n_ create table  _i_ create hline
_u_ undo
_q_ quit

"
  ("n" org-table-create "create table")
  ("r" org-table-insert-row "insert row")
  ("c" org-table-insert-column "insert col")

  ("v" org-table-delete-column "delete col")
  ("d" org-table-kill-row "delete row")
  ("i" org-table-insert-hline "hline")

  ("u" undo-fu-only-undo "undo")

  ("h" org-table-move-column-left "move col left")
  ("l" org-table-move-column-right "move col right")
  ("k" org-table-move-row-up "move row up")
  ("j" org-table-move-row-down "move row down")

  ("<left>" org-table-previous-field)
  ("<right>" org-table-next-field)
  ("<up>" previous-line)
  ("<down>" org-table-next-row)

  ("q" nil "quit"))

  (use-package corfu
    :init
    (global-corfu-mode)
    :config
    (setq corfu-auto t
          corfu-echo-documentation t
          corfu-scroll-margin 0
          corfu-count 8
          corfu-max-width 50
          corfu-min-width corfu-max-width
          corfu-auto-prefix 2)

    ;; Make Evil and Corfu play nice
;    (evil-make-overriding-map corfu-map)
;  (advice-add 'corfu--setup :after 'evil-normalize-keymaps)
;  (advice-add 'corfu--teardown :after 'evil-normalize-keymaps)

    (corfu-history-mode 1)
    (savehist-mode 1)
    (add-to-list 'savehist-additional-variables 'corfu-history)

    (defun corfu-enable-always-in-minibuffer ()
      (setq-local corfu-auto nil)
      (corfu-mode 1))
    (add-hook 'minibuffer-setup-hook #'corfu-enable-always-in-minibuffer 1)

    :general
    (:keymaps 'corfu-map
              :states 'insert
              "C-n" 'corfu-next
              "C-p" 'corfu-previous
              "C-j" 'corfu-next
              "C-k" 'corfu-previous
              "RET" 'corfu-complete
              "<escape>" 'corfu-quit
              ))

  (use-package cape
    :init
    (add-to-list 'completion-at-point-functions #'cape-file)
    (add-to-list 'completion-at-point-functions #'cape-keyword)
    ;; kinda confusing re length, WIP/TODO
    ;; :hook (org-mode . (lambda () (add-to-list 'completion-at-point-functions #'cape-dabbrev)))
    ;; :config
    ;; (setq dabbrev-check-other-buffers nil
    ;;       dabbrev-check-all-buffers nil
    ;;       cape-dabbrev-min-length 6)
    )


  (use-package kind-icon
    :config
    (setq kind-icon-default-face 'corfu-default)
    (setq kind-icon-default-style '(:padding 0 :stroke 0 :margin 0 :radius 0 :height 0.9 :scale 1))
    (setq kind-icon-blend-frac 0.08)
    (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter)
    (add-hook 'counsel-load-theme #'(lambda () (interactive) (kind-icon-reset-cache)))
    (add-hook 'load-theme         #'(lambda () (interactive) (kind-icon-reset-cache))))

  ;; "Enable Flyspell mode, which highlights all misspelled words. "
(use-package flyspell
  :defer t
  :config
  (add-to-list 'ispell-skip-region-alist '("~" "~"))
  (add-to-list 'ispell-skip-region-alist '("=" "="))
  (add-to-list 'ispell-skip-region-alist '("^#\\+BEGIN_SRC" . "^#\\+END_SRC"))
  (add-to-list 'ispell-skip-region-alist '("^#\\+BEGIN_EXPORT" . "^#\\+END_EXPORT"))
  (add-to-list 'ispell-skip-region-alist '("^#\\+BEGIN_EXPORT" . "^#\\+END_EXPORT"))
  (add-to-list 'ispell-skip-region-alist '(":\\(PROPERTIES\\|LOGBOOK\\):" . ":END:"))

  (dolist (mode '(
                  ;;org-mode-hook
                  mu4e-compose-mode-hook))
    (add-hook mode (lambda () (flyspell-mode 1))))

  (setq flyspell-issue-welcome-flag nil
        flyspell-issue-message-flag nil)

  :general ;; Switches correct word from middle click to right click
  (general-define-key :keymaps 'flyspell-mouse-map
                      "<mouse-3>" #'ispell-word
                      "<mouse-2>" nil)
  (general-define-key :keymaps 'evil-motion-state-map
                      "zz" #'ispell-word)
  )

;; (use-package flyspell-correct
;;   :after flyspell
;;   :bind (:map flyspell-mode-map ("C-;" . flyspell-correct-wrapper)))

;; (use-package flyspell-correct-ivy
;;   :after flyspell-correct)

  (use-package eglot
  :bind (:map eglot-mode-map
              ("C-c d" . eldoc)
              ("C-c a" . eglot-code-actions)
;              ("C-c f" . flymake-show-buffer-diagnostics)
              ("C-c r" . eglot-rename)))
  (desktop-save-mode 1)

  (use-package highlight-indent-guides
  :hook (python-ts-mode . highlight-indent-guides-mode)
  :config
  (set-face-foreground 'highlight-indent-guides-character-face "white")
  (setq highlight-indent-guides-method 'character))


  ;  (use-package eglot
  ;    :hook (python-base-mode . eglot-ensure)
  ;    :custom (eglot-autopshutdown t))

;; (use-package python
;; :bind (:map python-ts-mode-map
;;             ("<f5>" . recompile)
;;             ("<f6>" . eglot-format))
;; :hook ((python-ts-mode . eglot-ensure)
;;        (python-ts-mode . company-mode))
;; :mode (("\\.py\\'" . python-ts-mode)))

;; (use-package python-mode :defer t)
;; (general-define-key :states '(emacs) :keymaps 'inferior-python-mode-map
;;                     "<up>" 'comint-previous-input
;;                     "<down>" 'comint-next-input)

(use-package python-mode
                       :ensure t
                       :hook (python-mode . lsp-deferred)
                       :custom
                       (dap-python-debugger 'debugpy)
                       :config
                       (require 'dap-python))

;  (use-package typescript-mode
;    :mode "\\.ts\\'"
;    :hook (typescript-mode .lsp-deferred)
;    :config
;    (setq typescript-indent-level 2))

  (use-package company
    :after lsp-mode
    :hook (lsp-mode . company-mode)
    :bind (:map company-active-map
                ("<tab>" . company-complete-selection))
    (:map lsp-mode-map
          ("<tab>" . company-indent-or-complete-common))
    :custom
    (company-minimum-prefix-length 1)
    (company-idle-delay 0.5))

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

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

(use-package term
  :commands term
  :config
  (setq explicit-shell-file-name "fish"))

(use-package eterm-256color
  :hook (term-mode . eterm-256color-mode))

(use-package vterm
  :commands vterm
  :config
  (setq vterm-shell "fish")
  (setq vterm-max-scrollback 10000))

(defun efs/configure-eshell ()
  (add-hook 'eshell-pre-command-hook 'eshell-save-some-history)
  (add-to-list 'eshell-output-filter-functions 'eshell-truncate-buffer)
  (evil-define-key '(normal insert visual) eshell-mode-map (kbd "C-r") 'counsel-esh-history)
  (evil-define-key '(normal insert visual) eshell-mode-map (kbd "<home>") 'eshell-bol)
  (evil-normalize-keymaps)
  (setq eshell-history-size 10000
        eshell-buffer-maximum-lines 10000
        eshell-hist-ignoredups t
        eshell-scroll-to-bottom-on-input t))

(use-package eshell-git-prompt
  :after eshell)

(use-package eshell
  :hook (eshell-first-time-mode . efs/configure-eshell)
  :config
  (with-eval-after-load 'esh-opt
    (setq eshell-destroy-buffer-when-process-dies t)
    (setq eshell-visual-commands '("htop" "zsh" "vim")))
(eshell-git-prompt-use-theme 'powerline))

      (use-package org-super-agenda
        :after org
        :config
        (setq org-super-agenda-header-map nil) ;; takes over 'j'
        (add-hook 'org-agenda-mode-hook
                  #'(lambda () (setq-local nobreak-char-display nil)))
        (org-super-agenda-mode))

      (use-package org-superstar
        :config
        (setq org-superstar-leading-bullet " ")
        (setq org-superstar-special-todo-items t) ;; makes todo header bullets into boxes
        (setq org-superstar-todo-bullet-alist '(("TODO" . 9744)
                                              ("IN PROGRESS" . 9744)
                                              ("WAITING" . 9744)
                                              ("DONE" . 9745)
                                              ("BACKLOG" . 9744)
                                              ("PLAN" . 9744)
                                              ("READY" . 9744)
                                              ("ACTIVE" . 9744)
                                              ("REVIEW" . 9744)
                                              ("WAIT" . 9744)
                                              ("HOLD" . 9744)
                                              ("COMPLETED" . 9745)
                                              ("CANC" . 9745))))

      (setq org-blank-before-new-entry '((heading . nil) (plain-list-item . nil)))




       (defun efs/org-mode-setup ()
         (org-indent-mode)
         (variable-pitch-mode 1)
         (auto-fill-mode 0)
         (visual-line-mode 1)
         (setq evil-auto-indent nil))

       (defun efs/org-font-setup ()
         (font-lock-add-keywords 'org-mode
                                 '(("^ *\\([-]\\) "
                                    (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•"))))))
         (dolist (face '((org-level-1 . 1.2)
                         (org-level-2 . 1.1)
                         (org-level-3 . 1.05)
                         (org-level-4 . 1.0)
                         (org-level-5 . 1.1)
                         (org-level-6 . 1.1)
                         (org-level-7 . 1.1)
                         (org-level-8 . 1.1)))
           (set-face-attribute (car face) nil :font "Cantarell" :weight 'regular :height (cdr face)))
         (set-face-attribute 'org-block nil :foreground nil :inherit 'fixed-pitch)
         (set-face-attribute 'org-code nil :inherit '(shadow fixed-pitch))
         (set-face-attribute 'org-table nil :inherit '(shadow fixed-pitch))
         (set-face-attribute 'org-verbatim nil :inherit '(shadow fixed-pitch))
         (set-face-attribute 'org-special-keyword nil :inherit '(font-lock-comment-face fixed-pitch))
         (set-face-attribute 'org-checkbox nil :inherit 'fixed-pitch))

      (defface lik-read
        '((t (:foreground "MediumPurple2")))
        "custom face for highlighting read"
        :group 'lik)


  (defun lik/save-and-close-this-buffer (buffer)
  "Saves and closes given buffer."
  (if (get-buffer buffer)
      (let ((b (get-buffer buffer)))
        (save-buffer b)
        (kill-buffer b))))



  (defun lik/post-org-goto ()
    (let ((current-prefix-arg '(4))) ;; emulate C-u
      (call-interactively 'org-reveal))
    (org-cycle)

  (advice-add 'counsel-org-goto :after #'lik/post-org-goto)
  (advice-add 'org-agenda-goto :after #'lik/post-org-goto)
  (advice-add 'org-agenda-switch-to :after #'lik/post-org-goto))
;        (efs/org-font-setup))

 (use-package org-bullets
   :after org
   :hook (org-mode . org-bullets-mode)
   :custom
   (org-bullets-bullet-list '("◉" "○" "○" "○")))

    ;; https://www.reddit.com/r/emacs/comments/8qm1lb/new_orgcountwords_command/
  (defun ap/org-forward-to-entry-content (&optional unsafe)
    "Skip headline, planning line, and all drawers in current entry.
  If UNSAFE is non-nil, assume point is on headline."
    (unless unsafe
      ;; To improve performance in loops (e.g. with `org-map-entries')
      (org-back-to-heading))
    (cl-loop for element = (org-element-at-point)
             for pos = (pcase element
                         (`(headline . ,_) (org-element-property :contents-begin element))
                         (`(,(or 'planning 'property-drawer 'drawer) . ,_) (org-element-property :end element)))
             while pos
             do (goto-char pos)))
(defun ap/org-count-words ()
  "If region is active, count words in it; otherwise count words in current subtree."
  (interactive)
  (if (use-region-p)
      (funcall-interactively #'count-words-region (region-beginning) (region-end))
    (org-with-wide-buffer
     (cl-loop for (lines words characters)
              in (org-map-entries
                  (lambda ()
                    (ap/org-forward-to-entry-content 'unsafe)
                    (let ((end (org-entry-end-position)))
                      (list (count-lines (point) end)
                            (count-words (point) end)
                            (- end (point)))))
                  nil 'tree)
              sum lines into total-lines
              sum words into total-words
              sum characters into total-characters
              finally do (message "Subtree \"%s\" has %s lines, %s words, and %s characters."
                                  (org-get-heading t t) total-lines total-words total-characters)))))
  (defun lik/org-done-keep-todo ()
    "mark an org todo item as done while keeping its former keyword intact, and archive.
  for example, * TODO this item becomes * DONE TODO this item"
    (interactive)
    (let ((state (org-get-todo-state)) (tag (org-get-tags)) (todo (org-entry-get (point "TODO"))
                                                                  post-command-hook)
          (if (not (eq state nil))
              (progn (org-back-to-heading)
                     (org-todo "DONE")
                     (org-set-tags tag)
                     (beginning-of-line)
                     (forward-word)
                     (insert (concat " " todo)))
            (user-error "not a todo"))
          (run-hooks 'post-command-hook))))
    (defun lik/org-done-keep-todo-and-archive ()
  "Same as `lik/org-done-keep-todo' but archives heading as well."
  (interactive)
  (let ((state (org-get-todo-state)) (tag (org-get-tags)) (todo (org-entry-get (point) "TODO"))
        post-command-hook)
    (if (not (eq state nil))
        (progn (org-back-to-heading)
                           (org-todo "DONE")
                           (org-set-tags tag)
                           (beginning-of-line)
                           (forward-word)
                           (insert (concat " " todo))
                           (org-archive-subtree-default))
          (user-error "Not a TODO."))
    (run-hooks 'post-command-hook)))

(defun lik/org-archive-ql-search ()
  "Input or select a tag to search in my archive files."
  (interactive)
  (let* ((choices '("bv" "sp" "ch" "cl" "es" "Robotics ec" "Weekly ec")) ;; TODO get these with org-current-tag-alist
                 (tag (completing-read "Tag: " choices)))
        (org-ql-search
          ;; Recursively get all .org_archive files from my archive directory
          (directory-files-recursively
           (expand-file-name "org-archive" org-directory) ".org_archive")
          ;; Has the matching tags (can be a property or just a tag) and is a todo - done or not
          `(and (or (property "ARCHIVE_ITAGS" ,tag) (tags ,tag)) (or (todo) (done))))))




      (setq org-special-ctrl-a/e t)


    (general-def
      :states 'normal
      :keymaps 'org-mode-map
      "t" 'org-todo
      "<return>" 'org-open-at-point-global
      "K" 'org-shiftup
      "J" 'org-shiftdown
      "<f5>" 'org-ctrl-c-ctrl-c)

    (general-def
      :states 'insert
      :keymaps 'org-mode-map
      "C-o" 'evil-org-open-above
      "S-<left>" 'org-shiftleft
      "S-<right>" 'org-shiftright)

    (general-def
      :keymaps 'org-mode-map
      "M-[" 'org-metaleft
      "M-]" 'org-metaright
      "C-M-=" 'ap/org-count-words
      "C-M-r" 'org-refile
      "M-k" 'org-insert-link
      "C-c t" 'lik/org-done-keep-todo)

    ;; Org-src - when editing an org source block
    (general-def
      :prefix ","
      :states 'normal
      :keymaps 'org-src-mode-map
      "b" '(nil :which-key "org src")
      "bc" 'org-edit-src-abort
      "bb" 'org-edit-src-exit)

(defun efs/read-file-as-string (path)
  (with-temp-buffer
    (insert-file-contents path)
    (buffer-string)))

(push '("conf-unix" . conf-unix) org-src-lang-modes)

  (defun dw/minibuffer-backward-kill (arg)
  "When minibuffer is completing a file name delete up to parent
folder, otherwise delete a character backward"
  (interactive "p")
  (if minibuffer-completing-file-name
      ;; Borrowed from https://github.com/raxod502/selectrum/issues/498#issuecomment-803283608
      (if (string-match-p "/." (minibuffer-contents))
          (zap-up-to-char (- arg) ?/)
        (delete-minibuffer-contents))
      (delete-backward-char arg)))
               ;; Enable vertico
  (use-package vertico
    :bind (:map minibuffer-local-map
                          ("<backspace>" . dw/minibuffer-backward-kill))

          :custom
          ;; (vertico-scroll-margin 0) ;; Different scroll margin
          ;; (vertico-count 20) ;; Show more candidates
          ;; (vertico-resize t) ;; Grow and shrink the Vertico minibuffer
          ;; (vertico-cycle t) ;; Enable cycling for `vertico-next/previous'
          (keymap-set vertico-map "?" #'minibuffer-completion-help)
          (keymap-set vertico-map "M-TAB" #'minibuffer-complete)

          :init
          (vertico-mode))

        ;; Persist history over Emacs restarts. Vertico sorts by history position.
        (use-package savehist
          :init
          (savehist-mode))
(use-package marginalia
  :after vertico
  :ensure t
  :custom
  (marginalia-annotators '(marginalia-annotators-heavy marginalia-annotators-light nil))
  :init
  (marginalia-mode))


        ;; A few more useful configurations...
        (use-package emacs
          :custom
          ;; Support opening new minibuffers from inside existing minibuffers.
          (enable-recursive-minibuffers t)
          ;; Hide commands in M-x which do not work in the current mode.  Vertico
          ;; commands are hidden in normal buffers. This setting is useful beyond
          ;; Vertico.
          (read-extended-command-predicate #'command-completion-default-include-p)
          :init
          ;; Add prompt indicator to `completing-read-multiple'.
          ;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
          (defun crm-indicator (args)
            (cons (format "[CRM%s] %s"
                          (replace-regexp-in-string
                           "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
                           crm-separator)
                          (car args))
                  (cdr args)))
          (advice-add #'completing-read-multiple :filter-args #'crm-indicator)

          ;; Do not allow the cursor in the minibuffer prompt
          (setq minibuffer-prompt-properties
                '(read-only t cursor-intangible t face minibuffer-prompt))
          (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode))

        (use-package orderless
        :custom
        ;; Configure a custom style dispatcher (see the Consult wiki)
        ;; (orderless-style-dispatchers '(+orderless-consult-dispatch orderless-affix-dispatch))
        ;; (orderless-component-separator #'orderless-escapable-split-on-space)
        (completion-styles '(orderless basic))
        (completion-category-defaults nil)
        (completion-category-overrides '((file (styles partial-completion)))))

        (setq completion-styles '(basic substring partial-completion flex))
        (setq read-file-name-completion-ignore-case t
            read-buffer-completion-ignore-case t
            completion-ignore-case t)
        (setq completion-in-region-function
            (lambda (&rest args)
              (apply (if vertico-mode
                         #'consult-completion-in-region)
                     args)))

        (use-package vertico-directory
        :after vertico
        :straight nil
        ;; More convenient directory navigation commands
        :bind (:map vertico-map
                    ("RET" . vertico-directory-enter)
                    ("DEL" . vertico-directory-delete-char)
                    ("M-DEL" . vertico-directory-delete-word))
        ;; Tidy shadowed file names
        :hook (rfn-eshadow-update-overlay . vertico-directory-tidy))

        (vertico-multiform-mode)

      ;; Configure the display per command.
      ;; Use a buffer with indices for imenu
      ;; and a flat (Ido-like) menu for M-x.
      (setq vertico-multiform-commands
            '((consult-imenu buffer indexed)
              (execute-extended-command unobtrusive)))

      ;; Configure the display per completion category.
      ;; Use the grid display for files and a buffer
      ;; for the consult-grep commands.
      (setq vertico-multiform-categories
            '((file grid)
              (consult-grep buffer)))

      (setq vertico-multiform-commands
          `((consult-outline buffer ,(lambda (_) (text-scale-set -1)))))

      ;; Change the default sorting function.
    ;; See `vertico-sort-function' and `vertico-sort-override-function'.
    (setq vertico-multiform-commands
          '((describe-symbol (vertico-sort-function . vertico-sort-alpha))))

    (setq vertico-multiform-categories
          '((symbol (vertico-sort-function . vertico-sort-alpha))
            (file (vertico-sort-function . sort-directories-first))))

    ;; Sort directories before files
    (defun sort-directories-first (files)
      (setq files (vertico-sort-history-length-alpha files))
      (nconc (seq-filter (lambda (x) (string-suffix-p "/" x)) files)
             (seq-remove (lambda (x) (string-suffix-p "/" x)) files)))

    ;; Configure the buffer display and the buffer display action
  (setq vertico-multiform-categories
        '((consult-grep
           buffer
           (vertico-buffer-display-action . (display-buffer-same-window)))))

  ;; Disable preview for consult-grep commands

  (setq vertico-multiform-categories
      '((buffer flat (vertico-cycle . t))))

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

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

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

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

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

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

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

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


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

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

;  (use-package nix-mode
;      :mode ("\\.nix\\'"))
;  (use-package org-nix-shell
;    :straight '(org-nix-shell
;                         :type git
;                         :host github
;                         :repo "AntonHakansson/org-nix-shell")
;    :hook (org-mode . org-nix-shell-mode))

(use-package nix-mode
                       :mode ("\\.nix\\'" "\\.nix.in\\'"))

;   (use-package treemacs

;     :defer t
;  ;   :init
  ;   (with-eval-after-load 'winum
  ;     (define-key winum-keymap (kbd "M-0") #'treemacs-select-window))
;     :config
;     (progn
;       (setq treemacs-collapse-dirs (if treemacs-python-executable 3 0)
;             treemacs-deferred-git-apply-delay 0.5
;             treemacs-directory-name-transformer      #'identity
;             treemacs-display-in-side-window          t
 ;            treemacs-eldoc-display                   'simple
 ;            treemacs-file-event-delay                2000
;             treemacs-file-extension-regex            treemacs-last-period-regex-value
;             treemacs-file-follow-delay               0.2
;             treemacs-file-name-transformer           #'identity
;             treemacs-follow-after-init               t
 ;            treemacs-expand-after-init               t
 ;            treemacs-find-workspace-method           'find-for-file-or-pick-first
 ;            treemacs-git-command-pipe                ""
 ;            treemacs-goto-tag-strategy               'refetch-index
 ;            treemacs-header-scroll-indicators        '(nil . "^^^^^^")
 ;            treemacs-hide-dot-git-directory          t
 ;            treemacs-indentation                     2
 ;            treemacs-indentation-string              " "
 ;            treemacs-is-never-other-window           nil
 ;            treemacs-max-git-entries                 5000
 ;            treemacs-missing-project-action          'ask
 ;            treemacs-move-files-by-mouse-dragging    t
 ;            treemacs-move-forward-on-expand          nil
 ;            treemacs-no-png-images                   nil
 ;            treemacs-no-delete-other-windows         t
 ;            treemacs-project-follow-cleanup          nil
 ;            treemacs-persist-file                    (expand-file-name ".cache/treemacs-persist" user-emacs-directory)
 ;            treemacs-position                        'left
 ;            treemacs-read-string-input               'from-child-frame
  ;           treemacs-recenter-distance               0.1
 ;            treemacs-recenter-after-file-follow      nil
 ;            treemacs-recenter-after-tag-follow       nil
  ;           treemacs-recenter-after-project-jump     'always
  ;           treemacs-recenter-after-project-expand   'on-distance
  ;           treemacs-litter-directories              '("/node_modules" "/.venv" "/.cask")
  ;           treemacs-project-follow-into-home        nil
  ;           treemacs-show-cursor                     nil
  ;           treemacs-show-hidden-files               t
  ;           treemacs-silent-filewatch                nil
  ;           treemacs-silent-refresh                  nil
  ;           treemacs-sorting                         'alphabetic-asc
  ;           treemacs-select-when-already-in-treemacs 'move-back
  ;           treemacs-space-between-root-nodes        t
  ;           treemacs-tag-follow-cleanup              t
  ;           treemacs-tag-follow-delay                1.5
  ;           treemacs-text-scale                      nil
  ;           treemacs-user-mode-line-format           nil
  ;           treemacs-user-header-line-format         nil
  ;           treemacs-wide-toggle-width               70
  ;           treemacs-width                           35
  ;           treemacs-width-increment                 1
  ;           treemacs-width-is-initially-locked       t
  ;           treemacs-workspace-switch-cleanup        nil)

       ;; The default width and height of the icons is 22 pixels. If you are
       ;; using a Hi-DPI display, uncomment this to double the icon size.
       ;;(treemacs-resize-icons 44)

;       (treemacs-follow-mode t)
;       (treemacs-filewatch-mode t)
;       (treemacs-fringe-indicator-mode 'always)
;       (when treemacs-python-executable
;         (treemacs-git-commit-diff-mode t))

;       (pcase (cons (not (null (executable-find "git")))
;                    (not (null treemacs-python-executable)))
;         (`(t . t)
;          (treemacs-git-mode 'deferred))
;         (`(t . _)
;          (treemacs-git-mode 'simple)))

;       (treemacs-hide-gitignored-files-mode nil))
;     :bind
;     (:map global-map
;           ("M-0"       . treemacs-select-window)
 ;          ("C-x t 1"   . treemacs-delete-other-windows)
 ;          ("C-x t t"   . treemacs)
 ;          ("C-x t d"   . treemacs-select-directory)
 ;          ("C-x t B"   . treemacs-bookmark)
;           ("C-x t C-t" . treemacs-find-file)
 ;          ("C-x t M-t" . treemacs-find-tag)))

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

;   (use-package treemacs-icons-dired
;     :hook (dired-mode . treemacs-icons-dired-enable-once)
;     )

;   (use-package treemacs-magit
;     :after (treemacs magit)
;     )
;


;   (use-package treemacs-tab-bar ;;treemacs-tab-bar if you use tab-bar-mode
;     :after (treemacs)

;     :config (treemacs-set-scope-type 'Tabs))

;   (treemacs-start-on-boot)

(setq js-indent-level 2)

;    (setq initial-buffer-choice "~/.emacs.d/start.org")
;    (define-minor-mode start-mode
;      "provide functions for custom start page"
;      :lighter " start"
;      :keymap (let ((map (make-sparse-keymap)))
;                ;;(define-key map (kbd "M-z") 'eshell)
;                (evil-define-key 'normal start-mode-map
;                  (kbd "C-u 1") '(lambda () (interactive) (find-file "~/.dotfiles/config.org"))
;                  (kbd "C-u 2") '(lambda () (interactive) (find-file "~/.dotfiles/config.el")))
;                map))
;  (add-hook 'start-mode-hook 'org-mode)
;  (add-hook 'start-mode-hook 'read-only-mode)
;  (add-hook 'start-mode-hook (lambda () (org-display-inline-images t)))
  ;  (provide 'start-mode)
  ;    (add-hook mode (lambda () (display-line-numbers-mode 0))))

(use-package dashboard
  :config
  (setq initial-buffer-choice (lambda () (get-buffer-create dashboard-buffer-name)))
  (dashboard-setup-startup-hook)
  (setq dashboard-banner-logo-title "welcome to emacs")
  (setq dashboard-startup-banner 'logo)
  (setq dashboard-center-content t)
  (setq dashboard-vertically-center-content t)
  (setq dashboard-items '((recents . 3)
                          (bookmarks . 5)
                          (agenda . 3)))
  (setq dashboard-agenda-sort-strategy '(time-up habit-down priority-down category-keep))
  (setq dashboard-agenda-time-string-format "%d-%m %a"))

(use-package perspective
  :bind (
         ("C-x k" . persp-kill-buffer*)
         ("C-x C-b" . persp-list-buffers)
         ("C-x x s" . persp-switch)
         ("C-x x n" . persp-next)
         ("C-x x p" . persp-prev)
         ("C-x x a" . persp-add-buffer)
         ("C-x x A" . persp-set-buffer)
         ("C-x x k" . persp-remove)
         ("C-x x c" . persp-kill)
         ("C-x x C" . persp-kill-others))
  :custom
  (persp-mode-prefix-key (kbd "C-z"))
  :init
  (persp-mode))

  (global-display-line-numbers-mode)
  (add-to-list 'safe-local-variable-values '(org-roam-directory . "~/Documents/wizr/meetingnotes"))
  (add-to-list 'safe-local-variable-values '(org-roam-db-location . "~/Documents/wizr/meetingnotes/org-roam.db"))

  (use-package unfill :defer t)
  (use-package burly :defer t)
  (use-package burly :defer t)
  (use-package ace-window :defer t)
  (use-package centered-cursor-mode :diminish centered-cursor-mode)
  (use-package restart-emacs :defer t)
  (use-package diminish)
  (use-package bufler
  :config
  (setq bufler-filter-buffer-modes nil ;; Don't hide so many buffers
        bufler-filter-buffer-name-regexps nil)
  (setf bufler-groups (bufler-defgroups
                        (group
                         ;; Subgroup collecting all named workspaces.
                         (auto-workspace))
                        (group
                         ;; Subgroup collecting all `help-mode' and `info-mode' buffers.
                         (group-or "*Help/Info*"
                                   (mode-match "*Help*" (rx bos "help-"))
                                   (mode-match "*Info*" (rx bos "info-"))))
                        (group
                         ;; Subgroup collecting all special buffers (i.e. ones that are not
                         ;; file-backed), except `magit-status-mode' buffers (which are allowed to fall
                         ;; through to other groups, so they end up grouped with their project buffers).
                         (group-and "*Special*"
                                    (lambda (buffer)
                                      (unless (or (funcall (mode-match "Magit" (rx bos "magit-status"))
                                                           buffer)
                                                  (funcall (mode-match "Dired" (rx bos "dired"))
                                                           buffer)
                                                  (funcall (auto-file) buffer))
                                        "*Special*")))
                         (group
                          ;; Subgroup collecting these "special special" buffers
                          ;; separately for convenience.
                          (name-match "**Special**"
                                      (rx bos "*" (or "Messages" "Warnings" "scratch" "Backtrace") "*")))
                         (group
                          ;; Subgroup collecting all other Magit buffers, grouped by directory.
                          (mode-match "*Magit* (non-status)" (rx bos (or "magit" "forge") "-"))
                          (auto-directory))
                         ;; Remaining special buffers are grouped automatically by mode.
                         ;; (auto-mode)
                         )
                        (group (dir "~/Dropbox/notes/")
                               (auto-mode)
                               (auto-directory))
                        (group (dir "~/Dropbox/org/"))
                        ;; Group remaining buffers by directory, then major mode.
                        (auto-directory)
                        (auto-mode)))
  :general
  (:keymaps 'bufler-list-mode-map "Q" 'kill-this-buffer))

(use-package hl-prog-extra
  :commands (hl-prog-extra-mode)
  :config
  (setq hl-prog-extra-list
        (list
         '("\\<\\(TODO\\|NOTE\\)\\(([^)+]+)\\)?" 0 comment
           (:weight bold :inherit diff-removed))
         ;; Match TKs in quotation marks (hl-prog-extra sees them as strings)
         '("\\(TK\\)+" 0 string '(:weight bold :inherit font-lock-warning-face))
         ;; Match TKs not in quotation marks
         '("\\(TK\\)+" 0 nil '(:weight bold :inherit font-lock-warning-face))))
  (global-hl-prog-extra-mode))

(use-package xwidget
  :general
  (general-define-key :states 'normal :keymaps 'xwidget-webkit-mode-map 
                      "j" 'xwidget-webkit-scroll-up-line
                      "k" 'xwidget-webkit-scroll-down-line
                      "gg" 'xwidget-webkit-scroll-top
                      "G" 'xwidget-webkit-scroll-bottom))

(use-package mw-thesaurus
  :defer t
  :config
  (add-hook 'mw-thesaurus-mode-hook
            (lambda () (define-key evil-normal-state-local-map (kbd "q") 'mw-thesaurus--quit))))

(use-package ansi-term
  :straight nil
  :general
  (:keymaps 'term-mode-map
            "<up>" 'term-previous-input
            "<down>" 'term-next-input))

;;; https://github.com/oantolin/epithet
;(use-package epithet
;  :straight nil
;  :config
;  (add-hook 'Info-selection-hook #'epithet-rename-buffer)
;  (add-hook 'help-mode-hook #'epithet-rename-buffer))

;; https://github.com/udyantw/most-used-words
;(use-package most-used-words :straight nil)

  (defun lik/deft-kill ()
  (kill-buffer "*Deft*"))

(defun lik/deft-evil-fix ()
  (evil-insert-state)
  (centered-cursor-mode))

(use-package deft
  :config
  (setq deft-directory "/home/lik/Documents/notes/")
        deft-extensions '("org" "txt")
        deft-recursive t
        deft-file-limit 40
        deft-use-filename-as-title t)

  (add-hook 'deft-open-file-hook 'jib/deft-kill) ;; Once a file is opened, kill Deft
  (add-hook 'deft-mode-hook 'jib/deft-evil-fix) ;; Goes into insert mode automaticlly in Deft

  ;; Removes :PROPERTIES: from descriptions
  (setq deft-strip-summary-regexp ":PROPERTIES:\n\\(.+\n\\)+:END:\n")
  :general

  (general-define-key :states 'normal :keymaps 'deft-mode-map
                      ;; 'q' kills Deft in normal mode
                      "q" 'kill-this-buffer)

  (general-define-key :states 'insert :keymaps 'deft-mode-map
                      "C-j" 'next-line
                      "C-k" 'previous-line)

(use-package popper
:bind (("C-`"   . popper-toggle-latest)
       ("M-`"   . popper-cycle)
       ("C-M-`" . popper-toggle-type))
:init
(setq popper-reference-buffers
      '("\\*Messages\\*"
        "Output\\*$"
        "\\*Warnings\\*"
        help-mode
        compilation-mode))
(popper-mode +1))

(use-package rainbow-mode :defer t)
(use-package quickrun :defer t
  :general
  (general-define-key :states 'normal :keymaps 'quickrun--mode-map
                      "q" 'quit-window
                      "s-9" 'quickrun-shell))

(straight-use-package 'spacious-padding)
  (require 'spacious-padding)
  ;; these are the default values, but i keep them here for visibility
  (setq spacious-padding-widths
        '( :internal-border-width 15
           :header-line-width 4
           :mode-line-width 6
           :tab-width 4
           :right-divider-width 30
           :scroll-bar-width 8
           :fringe-width 8))
  ;; read the doc string of `spacious-padding-subtle-mode-line' as it
  ;; is very flexible and provides several examples
  (setq spacious-padding-subtle-mode-line
        `( :mode-line-active 'default
           :mode-line-inactive vertical-border))

  (spacious-padding-mode 1)

  ;; set a key binding if you need to toggle spacious padding
  (define-key global-map (kbd "<f8>") #'spacious-padding-mode)
  (define-key global-map (kbd "M-m") #'evil-normal-state)

(require 'dash)
(global-dash-fontify-mode)
(with-eval-after-load 'info-look
  (dash-register-info-lookup))

  (lik/load-theme 'doom-snazzy)
  (setq truncate-lines t)
;  (load "/home/lik/.emacs.d/private.el")
;  (setq org-agenda-private-local-path "/tmp/dummy.ics")

  ;; define a custom command to save the org agenda to a file
  (add-to-list 'org-agenda-custom-commands
               '("x" "export to ics"
                 ((agenda "" nil ,(list org-agenda-private-local-path)))))
  ;; (defun lik/org-agenda-export-to-ics ()
  ;;   (set-org-agenda-files)
  ;;   (org-batch-store-agenda-views)
  ;;   (with-current-buffer (find-file-noselect org-agenda-private-local-path)
  ;;     (goto-char (point-min))
  ;;     (while (re-search-forward "VTODO" nil t)
  ;;       (replace-match "VEVENT"))
  ;;     (save-buffer)))

(straight-use-package 'yuck-mode)
(straight-use-package 'lua-mode)
(tab-bar-mode nil)
(setq tab-bar-new-tab-choice "*dashboard*"
      tab-bar-close-button-show t
      tab-bar-new-button-show t)
(straight-use-package 'easy-kill)

(straight-use-package
 '(eat :type git
         :host codeberg
         :repo "akib/emacs-eat"
         :files ("*.el" ("term" "term/*.el") "*.texi"
                         "*.ti" ("terminfo/e" "terminfo/e*")
                         ("terminfo/65" "terminfo/65/*")
                         ("integration" "integration/*")
                         (:exclude ".dir-locals.el" "*-tests.el"))))

      (straight-use-package 'sudo-edit)
      (global-prettify-symbols-mode t)
      (global-hl-line-mode)
      (setq org-src-tab-acts-natively t)
      (setq org-src-window-setup 'current-window)
      (add-to-list 'org-structure-template-alist
                           '("el" . "src emacs-lisp"))
;       (use-package expand-region
;         :ensure t
;         :bind ("M-m" . er/expand-region))

 ;     (use-package org-auto-tangle
;       :defer t
;       :hook (org-mode . org-auto-tangle-mode)
;       :config
;       (setq org-auto-tangle-default t))
      ;  (use-package crux
      ;    :ensure td
      ;    :bind t
      ;    ("C-k" . crux-smart-kill-line))
      ;    ("C-c n" . crux-cleanup-buffer-or-region)
      ;    ("C-c f" . crux-recentf-find-file)

(setq warning-suppress-types '((project.el) (free variable)))

(use-package ledger-mode
  :ensure t
  :init
  (setq ledger-clear-whole-transactions 1)
  :config
  (add-to-list 'evil-emacs-state-modes 'ledger-report-mode)
  :mode ("\\.dat\\'"
             "\\.ledger\\'")
  :bind (:map ledger-mode-map
                      ("C-x C-s" . my/ledger-save))
  :preface
  (defun my/ledger-save ()
    "automatically clean the ledger buffer at each save"
    (interactive)
    (save-excursion
      (when (buffer-modified-p)
            (with-demoted-errors (ledger-mode-clean-buffer))
            (save-buffer)))))
(use-package flycheck-ledger :after ledger-mode)

  (defvar my/org-ledger-expense-template
  "%(org-read-date) * %^{Payee||blinkit|zomato|swiggy|jio|ather|mantri inn|thanishk|saravanan|bridgeway|equilibrium|curl up and dye|other}
    Expenses:%^{Category|food:meals|food:dining|vices:smokes|vices:alcohol|entertainment|entertainment:movie|entertainment:comedy|entertainment:music|house|books|office supplies|transportation:evren|transportation:cab|transportation:bus|transportation:other|gym:climbing|gym:regular|medical|selfcare|sim|other}               %^{Amount}
    Assets:%^{account|sbi|canara}" "Template for expense transaction with ledger.")
(defvar my/org-ledger-income-template
  "%(org-read-date) * %^{payee}
    Income:salary:%^{source}                 -%^{amount}
    Assets:sbi
" "template for income transaction with ledger")
(defvar my/org-ledger-receivable-template
  "%(org-read-date) * %^{payee}
    Receivables:%^{From|wizr|other}           -%^{amount}
    Assets:%^{To|sbi|canara|cash}" "template for receivables with ledger")
  (setq org-capture-templates
   `(("l" "Ledger")
     ("le" "Expense" plain (file ,(format "~/.personal/ledger/ledger-%s.dat" (format-time-string "%Y"))),
      my/org-ledger-expense-template
  :empty-lines 1)
     ("li" "Income" plain (file , (format "~/.personal/ledger/ledger-%s.dat"
                                                                             (format-time-string "%Y"))),
     my/org-ledger-income-template
     :empty-lines 1)
     ("lr" "Receivable" plain (file , (format
                                                                       "~/.personal/ledger/ledger-%s.dat"
                                                               (format-time-string "%Y"))),
      my/org-ledger-receivable-template
      :empty-lines 1)))

(straight-use-package 'org-present)
(require 'org-faces)
(defun lik/org-present-prepare-slide (buffer-name heading)
  (org-overview)
  (org-show-entry)
  (org-show-children))

(defun lik/org-present-start ()
  (setq-local face-remapping-alist '((default (:height 1.5) variable-pitch)
                                                                       (header-line (:height 4.0) variable-pitch)
                                                                       (org-document-title (:height 1.75) org-document-title)
                                                                       (org-code (:height 1.55) org-code)
                                                                       (org-verbatim (:height 1.55) org-verbatim)
                                                                       (org-block (:height 1.25) org-block)
                                                                       (org-block-begin-line (:height 0.7) org-block)))
  (setq header-line-format " ")
  (org-present-big)
  (org-present-hide-cursor)
  (org-present-read-only)
  (org-display-inline-images)
  (visual-fill-column-mode 1)
  (visual-line-mode 1))

(defun lik/org-present-end ()
  (setq-local face-remapping-alist '((default variable-pitch default)))
  (setq header-line-format nil)
  (org-present-small)
  (org-present-show-cursor)
  (org-present-read-write)
  (org-remove-inline-images)
  (visual-fill-column-mode 0)
  (visual-line-mode 0))
(add-hook 'org-present-mode-hook 'lik/org-present-start)
(add-hook 'org-present-mode-quit-hook 'lik/org-present-end)
(add-hook 'org-present-after-navigate-functions 'lik/org-present-prepare-slide)

(straight-use-package 'rust-mode)
(use-package rustic
                                        :ensure
                                        :bind (:map rustic-mode-map
                                                                ("M-j" . lsp-ui-imenu)
                                                                ("M-?" . lsp-find-references)
                                                                ("C-c C-c l" . flycheck-list-errors)
                                                                ("C-c C-c a" . lsp-execute-code-action)
                                                                ("C-c C-c r" . lsp-rename)
                                                                ("C-c C-c q" . lsp-workspace-restart)
                                                                ("C-c C-c Q" . lsp-workspace-shutdown)
                                                                ("C-c C-c s" . lsp-rust-analyzer-status))
                                        :config
                                        ;; uncomment for less flashiness
                                        ;; (setq lsp-eldoc-hook nil)
                                        ;; (setq lsp-enable-symbol-highlighting nil)
                                        ;; (setq lsp-signature-auto-activate nil)

                                        ;; comment to disable rustfmt on save
                                        (setq rustic-format-on-save t)
                                        (add-hook 'rustic-mode-hook 'lik/rustic-mode-hook))
(defun lik/rustic-mode-hook ()
  ;; so that run C-c C-c C-r works without having to confirm, but don't
  ;; try to save rust buffers that are not file visiting. once
  ;; https://github.com/brotzeit/rustic/issues/253 has been resolved this
  ;; should no longer be necessary
  (when buffer-file-name
      (setq-local buffer-save-without-query t))
  (add-hook 'before-save-hook 'lsp-format-buffer nil t))

  (use-package fzf
;    :init
;    (setenv "FZF_DEFAULT_COMMAND" "fd --type f")
    :config
    (setq fzf/args "-x --color bw --print-query --margin=1,0 --no-hscroll"
                fzf/executable "fzf"
                fzf/git-grep-args "-i --line-number %s"
                fzf/grep-command "rg --no-heading -nH"
                fzf/position-bottom t
                fzf/window-height 30))