Literate doom-emacs config

(setq resolution-factor 1.11) ;; default
(when (display-graphic-p)
  (setq resolution-factor (eval (/ (x-display-pixel-height) 1080.0)))
  )
(setq base-font-size 27.0)
(defvar hz/font-setup-verbose 'nil
  "If non-nil, display verbose messages about font setup.")

(when (display-graphic-p)
  (let ((font-list '("Intel One Mono"
                     "Cascadia Code PL"
                     "Attribute Mono"
                     "OperatorMono Nerd Font"
                     "Droid Sans Mono"
                     "Droid Sans Fallback"))
        (found-font nil))

    (dolist (font-name font-list)
      (if (find-font (font-spec :name font-name))
          (progn
            (setq user-font font-name)
            (setq found-font t))
        (when hz/font-setup-verbose
          (message "Font '%s' does not exist!" font-name))))

    (unless found-font
      (warn "No suitable font found. Using system defaults."))

    ;; Set the font weight based on the found font
    (setq user-font-weight
          (cond
           ((string= user-font "Droid Sans Mono") 'medium)
           (t 'normal)))

    ;; Set up the fonts using the found font and resolution factor
    (setq doom-font (font-spec :family user-font
                               :weight user-font-weight
                               :size (eval (round (* base-font-size resolution-factor))))
          doom-big-font (font-spec :family user-font
                                   :weight user-font-weight
                                   :size (eval (round (* (+ base-font-size 4) resolution-factor))))
          doom-variable-pitch-font (font-spec :family user-font
                                              :weight user-font-weight
                                              :size (eval (round (* (- base-font-size 1) resolution-factor))))
          doom-modeline-height (eval (round (* 36 resolution-factor)))

          )
    ))

;; Helm is no longer enabled (using vertico)
;; (setq +helm-posframe-text-scale 0)

(setq +doom-dashboard-banner-file (expand-file-name "banner.png" doom-private-dir))

(when (getenv "SHELL")
  (let ((user-shell (getenv "SHELL")))
    (when (or (string-match-p "fish" user-shell)
              (string-match-p "nu" user-shell))
      ;; Set a POSIX-compliant shell for internal Emacs processes
      (setq shell-file-name (executable-find "bash"))

      ;; Ensure Emacs terminal emulators still use the user's preferred shell
      (setq-default vterm-shell user-shell)
      (setq-default explicit-shell-file-name user-shell)

      ;; Also update the specific shell script variable if needed
      (setq-default sh-shell-file user-shell))))

(add-hook 'projectile-after-switch-project-hook (lambda () (projectile-invalidate-cache nil)))

(setq-hook! 'LaTeX-mode-hook +spellcheck-immediately nil)

(after! org
  (remove-hook 'after-save-hook #'+literate-recompile-maybe-h))

(set-file-template! "\\.org$" :ignore t)

;; Also like doom-city-lights, doom-oceanic-next, doom-tomorrow-night, doom-wilmersdorf, leuven, doom-monokai-pro, doom-solarized-dark-high-contrast
;; Light ones like solarized
(setq doom-theme 'doom-tomorrow-night)

(setq +format-on-save-enabled-modes '(not emacs-lisp-mode ; works well enough without it
                                          sql-mode        ; sqlformat is broken
                                          tex-mode        ; latexindent is broken
                                          latex-mode      ; latexindent is broken
                                          bibtex-mode     ; is broken
                                          ess-r-mode      ; styler takes forever
                                          web-mode      ; dunno who this is for
                                          ))

;; I like short names
(general-evil-setup t)
;; Stop telling me things begin with non-prefix keys
(general-auto-unbind-keys)

(map! :localleader
      :map markdown-mode-map
      :prefix ("i" . "Insert")
      :desc "Blockquote"    "q" 'markdown-insert-blockquote
      :desc "Bold"          "b" 'markdown-insert-bold
      :desc "Code"          "c" 'markdown-insert-code
      :desc "Emphasis"      "e" 'markdown-insert-italic
      :desc "Footnote"      "f" 'markdown-insert-footnote
      :desc "Code Block"    "s" 'markdown-insert-gfm-code-block
      :desc "Image"         "i" 'markdown-insert-image
      :desc "Link"          "l" 'markdown-insert-link
      :desc "List Item"     "n" 'markdown-insert-list-item
      :desc "Pre"           "p" 'markdown-insert-pre
      (:prefix ("h" . "Headings")
       :desc "One"   "1" 'markdown-insert-atx-1
       :desc "Two"   "2" 'markdown-insert-atx-2
       :desc "Three" "3" 'markdown-insert-atx-3
       :desc "Four"  "4" 'markdown-insert-atx-4
       :desc "Five"  "5" 'markdown-insert-atx-5
       :desc "Six"   "6" 'markdown-insert-atx-6))

(map! :localleader
      :map (org-mode-map pdf-view-mode-map)
      (:prefix ("o" . "Org")
        (:prefix ("n" . "Noter")
          :desc "Noter" "n" 'org-noter
          )))

(after! org (map! :localleader
                  :map org-mode-map
                  :desc "Eval Block" "e" 'ober-eval-block-in-repl
                  (:prefix "o"
                   :desc "Tags" "t" 'org-set-tags
                   :desc "Roam Bibtex" "b" 'orb-note-actions
                   (:prefix ("p" . "Properties")
                    :desc "Set" "s" 'org-set-property
                    :desc "Delete" "d" 'org-delete-property
                    :desc "Actions" "a" 'org-property-action
                    )
                   )
                  (:prefix ("i" . "Insert")
                   :desc "Link" "l" 'org-insert-link
                   :desc "Item" "o" 'org-toggle-item
                   :desc "Citation" "c" 'org-ref-insert-cite-link
                   :desc "Footnote" "f" 'org-footnote-action
                   :desc "Table" "t" 'org-table-create-or-convert-from-region
                   (:prefix ("d" . "Download")
                    :desc "Screenshot" "s" 'org-download-screenshot
                    :desc "Clipboard" "c" 'org-download-clipboard
                    :desc "Link" "l" 'org-download-image
                    )
                   (:prefix ("b" . "Math")
                    :desc "Bold" "f" 'org-make-bold-math
                    :desc "Blackboard" "b" 'org-make-blackboard-math
                    :desc "Remove" "r" 'org-make-symrm-math
                    :desc "Vert" "v" 'org-make-vert-math
                    )
                   (:prefix ("h" . "Headings")
                    :desc "Normal" "h" 'org-insert-heading
                    :desc "Todo" "t" 'org-insert-todo-heading
                    (:prefix ("s" . "Subheadings")
                     :desc "Normal" "s" 'org-insert-subheading
                     :desc "Todo" "t" 'org-insert-todo-subheading
                     )
                    )
                   (:prefix ("e" . "Exports")
                    :desc "Dispatch" "d" 'org-export-dispatch
                    )
                   )
                  )
  )

(map! :localleader
      :map org-mode-map
      (:prefix ("a" . "Anki")
       :desc "Push" "p" 'anki-editor-push-notes
       :desc "Retry" "r" 'anki-editor-retry-failure-notes
       :desc "Insert" "n" 'anki-editor-insert-note
       (:prefix ("c" . "Cloze")
        :desc "Dwim" "d" 'anki-editor-cloze-dwim
        :desc "Region" "r" 'anki-editor-cloze-region
        )
       )
      )

;; rtags is no longer installed; using clangd via eglot instead
(nmap
  :prefix my-leader
  :keymaps 'c-mode-base-map
  "m" '(:ignore t :wk "Local Commands")
  "m r" '(:ignore t :wk "Rtags")
  "m r c" '(rtags-check-includes :wk "Check Includes")
  "m r f" '(:ignore t :wk "Find")
  "m r f s" '(:ignore t :wk "Symbol")
  "m r f s a" '(rtags-find-symbol-at-point :wk "At point")
  "m r f s s" '(rtags-find-symbol :wk "Symbol")
  "m r f s c" '(:ignore t :wk "Current")
  "m r f s c f" '(rtags-find-symbol-current-file :wk "File")
  "m r f s c d" '(rtags-find-symbol-current-dir :wk "Directory")
  "m r f f" '(rtags-find-functions-called-by-this-function :wk "Functions")
  "m r f r" '(rtags-find-references :wk "References")
  )

(use-package! evil-colemak-basics
  :after evil
  :config
  (setq evil-colemak-basics-rotate-t-f-j t)
  (global-evil-colemak-basics-mode)
  )

(nmap
  :prefix my-leader
  :keymaps '(latex-mode-map tex-mode-map LaTeX-mode-map)
  ;; Folding Stuff
  "m f" '(:ignore t :wk "Fold Things")
  "m f c" '(TeX-fold-comment :wk "Comment")
  "m f e" '(TeX-fold-env :wk "Environment")
  "m f m" '(TeX-fold-math :wk "Math")
  ;; Insertions
  "m i" '(:ignore t :wk "Insert")
  "m i m" '(LaTeX-math-mode :wk "Math mode toggle")
  "m i r" '(:ignore t :wk "References")
  "m i r r" '(reftex-citation :wk "Reftex")
  )

(cond ((featurep :system 'macos) (use-package! exec-path-from-shell
                                   :config
                                   (exec-path-from-shell-initialize)
                                   )
       ))

(use-package! epa-file
  :demand
  :config
  (epa-file-enable)
  )

(after! epa-file
  (setq custom-file (concat doom-private-dir "local/private.el.gpg"))
  (load custom-file)
  (rg/bibtex-configure-paths)
  )

(setq org-export-async-init-file (concat doom-private-dir "local/async-ox.el"))
(load! "local/rg-compat")
(load! "local/rg-health")
(load! "local/rg-prose")
(load! "local/rg-snapper")
(load! "local/rg-vale")

(after! tramp
  (add-to-list 'tramp-remote-path "~/.local/bin")
  (add-to-list 'tramp-remote-path "~/.cargo/bin")
  (add-to-list 'tramp-remote-path "~/.hpc/bin")
  (add-to-list 'tramp-remote-path "~/.local/lsp/bin")
  (add-to-list 'tramp-remote-path "~/.micromamba/envs/lsp/bin/")
  (setq remote-file-name-inhibit-cache 60)
  (setq remote-file-name-inhibit-locks 't)
  (setq tramp-completion-reread-directory-timeout 60)
  (setq tramp-verbose 1)
  (setq tramp-inline-compress-start-size 1000)
  (setq tramp-default-method "sshx")
  (setq vc-ignore-dir-regexp (format "%s\\|%s\\|%s"
                                     vc-ignore-dir-regexp
                                     tramp-file-name-regexp
                                     "[/\\\\]node_modules")
        )
  (setq-default tramp-ssh-controlmaster-options
                "-o ControlMaster=auto -o ControlPath='/tmp/tramp.%%C' -o ControlPersist=90m")
  )

(after! eglot
  (add-hook 'nix-mode-hook 'eglot-ensure)
  (add-hook 'f90-mode-hook 'eglot-ensure)
  (set-eglot-client! 'cc-mode '("clangd" "-j=3" "--clang-tidy"))
  (set-eglot-client! 'python-mode '("uvx" "ruff" "server"))
  (set-eglot-client! 'org-mode '("harper-ls" "--stdio"))
  (set-eglot-client! 'markdown-mode '("harper-ls" "--stdio"))
  (set-eglot-client! 'text-mode '("harper-ls" "--stdio"))
  (set-eglot-client! 'latex-mode '("harper-ls" "--stdio"))
  (add-hook 'markdown-mode-hook 'eglot-ensure)
  (when (string= (system-name) "Rohits-MacBook-Pro.local")
    (setq exec-path (append exec-path '(
                                        (concat (getenv "HOME") "/.micromamba/envs/lsp/bin/") ;; python, fortran
                                        (concat (getenv "HOME") "/.local/lsp/bin/") ;; clangd
                                        (concat (getenv "HOME") "/.digestif/bin/") ;; tex
                                        (concat (getenv "HOME") "/.nvm/versions/node/v16.1.0/bin/bash-language-server")
                                        )))
    )
  )

(use-package! eglot-booster
  :after eglot
  :commands (eglot-booster-mode)
  :config
  (eglot-booster-mode)
  (set-eglot-client! 'python-mode '("emacs-lsp-booster" "uvx" "ruff" "server"))
  (set-eglot-client! 'cc-mode '("emacs-lsp-booster" "clangd" "-j=3" "--clang-tidy"))
  (set-eglot-client! '(rust-mode rust-ts-mode) '("emacs-lsp-booster" "rust-analyzer"))
  )

;; enable word-wrap in C/C++/ObjC/Java
(add-hook! 'markdown-mode-hook #'+word-wrap-mode)
(add-hook! 'text-mode-hook #'+word-wrap-mode)
(add-hook! 'tex-mode-hook #'+word-wrap-mode)

(after! spell-fu
  (let ((word-list "/usr/share/dict/cracklib-small"))
    (when (file-readable-p word-list)
      (setq ispell-alternate-dictionary word-list)))
  (setq spell-fu-idle-delay 0.5 ; default is 0.25
        ispell-program-name "aspell"
        ispell-extra-args '("--sug-mode=ultra")
        ispell-dictionary "en_US"
        ispell-personal-dictionary "~/.aspell.en.pws"
        spell-fu-dictionary "~/.config/dict")
  (ispell-change-dictionary "american" t)
  )

;; Can always be enabled with SPC t s
(remove-hook 'text-mode-hook #'spell-fu-mode)

(after! pdf-view
  ;; open pdfs scaled to fit page
  (setq-default pdf-view-display-size 'fit-width)
  (add-hook! 'pdf-view-mode-hook (evil-colemak-basics-mode -1))
  ;; automatically annotate highlights
  (setq pdf-annot-activate-created-annotations t
        pdf-view-resize-factor 1.1)
  ;; faster motion
  (map!
   :map pdf-view-mode-map
   :n "g g"          #'pdf-view-first-page
   :n "G"            #'pdf-view-last-page
   :n "N"            #'pdf-view-next-page-command
   :n "E"            #'pdf-view-previous-page-command
   :n "e"            #'evil-collection-pdf-view-previous-line-or-previous-page
   :n "n"            #'evil-collection-pdf-view-next-line-or-next-page
   :localleader
   (:prefix "o"
            (:prefix "n"
             :desc "Insert" "i" 'org-noter-insert-note
             ))
   ))

(setq org-log-done "time"
      org-log-done-with-time 't)

(use-package! ox-extra
  :after org
  :config
  (ox-extras-activate '(ignore-headlines))
  )

(setq org-file-apps
  '((auto-mode . emacs)
    ("\\.mm\\'" . default)
    ("\\.x?html?\\'" . default)
    ("\\.pdf\\'" . default)
    ("\\.png\\'" . viewnior)
    ("\\.jpg\\'" . viewnior)
    ("\\.svg\\'" . viewnior)
    ))

(use-package! mermaid-mode)
(use-package! ob-mermaid)

;; From https://github.com/poligen/dotfiles/blob/25785810f9bf98f6eec93e400c686a4ad65ac310/doom.d/config.el
;; My customized org-download to incorporate flameshot gui Workaround to setup flameshot, which enables annotation.
;; In flameshot, set filename as "screenshot", and the command as "flameshot gui -p /tmp", so that we always ends up
;; with /tmp/screenshot.png. Nullify org-download-screenshot-method by setting it to `echo', so that essentially we
;; are only calling (org-download-image org-download-screenshot-file).
(defun hz-org-download-screenshot ()
  "Capture screenshot and insert the resulting file.
The screenshot tool is determined by `org-download-screenshot-method'."
  (interactive)
  (let ((tmp-file "/tmp/screenshot.png"))
    (delete-file tmp-file)
    (call-process-shell-command "flameshot gui -p /tmp/")
    ;; Because flameshot exit immediately, keep polling to check file existence
    (while (not (file-exists-p tmp-file))
      (sleep-for 2))
    (org-download-image tmp-file)))

(use-package! org-download
  :after org
  :config
  (setq-default org-download-image-dir "./images/"
                ;; org-download-screenshot-method "flameshot gui --raw > %s"
                org-download-delete-image-after-download t
                org-download-method 'directory
                org-download-heading-lvl 1
                org-download-screenshot-file "/tmp/screenshot.png"
                )
  (cond ((featurep :system 'linux)
         (if (getenv "WAYLAND_DISPLAY")
             (setq-default org-download-screenshot-method "grim -g \"$(slurp)\" - > %s")
           (setq-default org-download-screenshot-method "xclip -selection clipboard -t image/png -o > %s")
           )
         )
        ((featurep :system 'macos) (setq-default org-download-screenshot-method "screencapture -i %s")))
  )

(after! org
  (org-babel-do-load-languages 'org-babel-load-languages
                               (append org-babel-load-languages
                                       ;; '((julia . t))
                                       '((mathematica . t))
                                       '((ditaa . t))
                                       )))
(setq org-babel-mathematica-command "~/.local/bin/mash"
      org-ditaa-jar-path (concat (getenv "HOME") "/.local/bin/ditaa0_9.jar")
)

(use-package! ox-awesomecv
  :after org
  :config
  (defun hz/org-export-to-file-awesomecv-tex ()
    (interactive)
    (let ((outfile (org-export-output-file-name ".tex")))
      (org-export-to-file 'awesomecv outfile)))
  )

(use-package! ox-moderncv
  :after org
  :config
  (defun hz/org-export-to-file-moderncv-tex ()
    (interactive)
    (let ((outfile (org-export-output-file-name ".tex")))
      (org-export-to-file 'moderncv outfile)))
  )

(use-package! org-babel-eval-in-repl
  :after org
  :config
  (setq eir-jump-after-eval nil)
  )

;; TODO: Figure out how to pass parameters other than width
;; TODO: Also make a subcaption label
(org-link-set-parameters
 "subfig"
 :follow (lambda (file) (find-file file))
 :face '(:foreground "chocolate" :weight bold :underline t)
 :display 'full
 :export (lambda (file desc backend)
           (when (eq backend 'latex)
             (if (string-match ">(\\(.+\\))" desc)
                 (concat "\\begin{subfigure}[b]{"
                         (match-string 1 desc)
                         "}\\caption{" (replace-regexp-in-string "\s+>(.+)" "" desc) "}"
                         "\\includegraphics"
                         "["
                         "width=\\textwidth"
                         "]"
                         "{"
                         file
                         "}"
                         "\\end{subfigure}"
                         )
               (format "\\begin{subfigure}[b]{\\textwidth}\\includegraphics{%s}\\caption{%s}\\end{subfigure}" file desc)))))

(use-package! org-ql
  :after org
  :commands (org-ql-search org-ql-view org-ql-find))

(after! org
  (map! :leader
        (:prefix ("o" . "open")
         :desc "Org heading (buffer)" "h" #'consult-org-heading
         :desc "Org heading (agenda)" "H" #'consult-org-agenda
         :desc "Org-ql find" "q" #'org-ql-find
         :desc "Org-ql search" "Q" #'org-ql-search)))

(use-package! org-mind-map
  :general
  (:keymaps 'org-mode-map
   :states 'normal
   :prefix my-leader
   "m e m" '(org-mind-map-write :wk "Export mind-map") ))

(use-package! org-modern
  :after org
  :config
  (setq global-org-modern-mode t)
)

(use-package! org-appear
  :hook (org-mode . org-appear-mode)
  :config
  (setq org-hide-emphasis-markers t
        org-appear-autoemphasis t
        org-appear-autolinks t
        org-appear-autosubmarkers t
        org-appear-autoentities t))

(use-package! laas
  :hook ((LaTeX-mode . laas-mode)
         (org-mode . laas-mode)))

(after! ox
  (require 'ox-chameleon))

(use-package! org-glossary
  :hook (org-mode . org-glossary-mode))

(use-package! orgdiff
  :after org
  :config
  (let ((texlive-bin (car (file-expand-wildcards
                           (expand-file-name "~/.local/share/texlive-*/bin/x86_64-linux")))))
    (when texlive-bin
      (add-to-list 'exec-path texlive-bin)
      (setenv "PATH" (concat texlive-bin ":" (getenv "PATH"))))))

(use-package! org-gantt
 :after org)

;;(use-package! org-drill
;;  :after org)

(after! org-re-reveal
  (use-package! org-re-reveal-ref) ; fixes org-ref
  (setq reveal-extras (concat doom-private-dir "reveal/extras/")
        org-re-reveal-root (concat doom-private-dir "reveal/rjs/")
        sfeir-root (concat doom-private-dir "reveal/sfeir-school-theme/"))
)

(use-package! org-gcal)

(let* ((hugo-section "posts")
       (emacs-major-version (car (version-to-list emacs-version)))
       (emacs-minor-version (nth 1 (version-to-list emacs-version)))
       (org-mode-version org-version)
       (hugo-creator-string (format "Emacs %s.%s (Org mode %s + ox-hugo + HaoZeke)"
                                    emacs-major-version
                                    emacs-minor-version
                                    org-mode-version))
       (org-creator-string (format "Emacs %s.%s (Org mode %s + HaoZeke)"
                                   emacs-major-version
                                   emacs-minor-version
                                   org-mode-version))
       (auto-set-lastmod 't)
       (suppress-period 43200.0))
  (setq org-hugo-auto-set-lastmod auto-set-lastmod
        org-hugo-section hugo-section
        org-hugo-suppress-lastmod-period suppress-period
        org-hugo-export-creator-string hugo-creator-string
        org-export-creator-string org-creator-string))

(after! ox-hugo
  (use-package! citeproc-org
    :config
    (citeproc-org-setup)
    (setq citeproc-org-org-bib-header "* References\n")
    )
  )

(after! citeproc-org
  (defun hz/min-headline-level ()
    (--> (org-element-parse-buffer)
         (org-element-map it 'headline (apply-partially #'org-element-property :level))
         (or it '(0))
         (-min it)))

  (defadvice! hz/citeproc-org-render-references (orig &rest args)
    :around 'citeproc-org-render-references
    (let* ((minlevel (hz/min-headline-level))
           (totallevel (max 1 minlevel))
           (citeproc-org-org-bib-header (concat (make-string totallevel ?*)
                                                (string-trim-left citeproc-org-org-bib-header "\\**"))))
      (apply orig args))))

(use-package! calctex
  :commands calctex-mode
  :init
  (add-hook 'calc-mode-hook #'calctex-mode)
  :config
  (setq calctex-additional-latex-packages "
\\usepackage[usenames]{xcolor}
\\usepackage{soul}
\\usepackage{adjustbox}
\\usepackage{amsmath}
\\usepackage{amssymb}
\\usepackage{siunitx}
\\usepackage{cancel}
\\usepackage{mathtools}
\\usepackage{mathalpha}
\\usepackage{xparse}
\\usepackage{arevmath}"
        calctex-additional-latex-macros
        (concat calctex-additional-latex-macros
                "\n\\let\\evalto\\Rightarrow"))
  (defadvice! no-messaging-a (orig-fn &rest args)
    :around #'calctex-default-dispatching-render-process
    (let ((inhibit-message t) message-log-max)
      (apply orig-fn args)))
  ;; Fix hardcoded dvichop path (whyyyyyyy)
  (let ((vendor-folder (concat (file-truename doom-local-dir)
                               "straight/"
                               (format "build-%s" emacs-version)
                               "/calctex/vendor/")))
    (setq calctex-dvichop-sty (concat vendor-folder "texd/dvichop")
          calctex-dvichop-bin (concat vendor-folder "texd/dvichop")))
  (unless (file-exists-p calctex-dvichop-bin)
    (message "CalcTeX: Building dvichop binary")
    (let ((default-directory (file-name-directory calctex-dvichop-bin)))
      (call-process "make" nil nil nil))))

(defvar calc-embedded-trail-window nil)
(defvar calc-embedded-calculator-window nil)

(defadvice! calc-embedded-with-side-pannel (&rest _)
  :after #'calc-do-embedded
  (when calc-embedded-trail-window
    (ignore-errors
      (delete-window calc-embedded-trail-window))
    (setq calc-embedded-trail-window nil))
  (when calc-embedded-calculator-window
    (ignore-errors
      (delete-window calc-embedded-calculator-window))
    (setq calc-embedded-calculator-window nil))
  (when (and calc-embedded-info
             (> (* (window-width) (window-height)) 1200))
    (let ((main-window (selected-window))
          (vertical-p (> (window-width) 80)))
      (select-window
       (setq calc-embedded-trail-window
             (if vertical-p
                 (split-window-horizontally (- (max 30 (/ (window-width) 3))))
               (split-window-vertically (- (max 8 (/ (window-height) 4)))))))
      (switch-to-buffer "*Calc Trail*")
      (select-window
       (setq calc-embedded-calculator-window
             (if vertical-p
                 (split-window-vertically -6)
               (split-window-horizontally (- (/ (window-width) 2))))))
      (switch-to-buffer "*Calculator*")
      (select-window main-window))))

(setq auto-mode-alist (append '(
                                ("\\.f\\'" . fortran-mode)
                                ("\\.f77\\'" . fortran-mode)
                                ("\\.f90\\'" . f90-mode)
                                ("\\.F90\\'" . f90-mode)
                                )
                              auto-mode-alist))

(use-package! quarto-mode)

(use-package! meson-mode
  :mode "\\.build\\'"
  :config
  (when (modulep! :completion company)
    (add-hook!'meson-mode-hook 'company-mode))
  )

(use-package! xonsh-mode
  :mode "\\.xsh\\'"
  :config
  (when (modulep! :completion company)
    (add-hook!'xonsh-mode-hook 'company-mode))
  )

(autoload 'pkgbuild-mode "pkgbuild-mode.el" "PKGBUILD mode." t)
(setq auto-mode-alist (append '(("/PKGBUILD$" . pkgbuild-mode))
                              auto-mode-alist))

(use-package! pkgbuild-mode
  :mode "\\PKGBUILD")

(use-package! pug-mode
  :mode "\\.pug\\'")

(setq auto-mode-alist
             (append
             '(("\\.rc\\'" . conf-mode))
             '(("\\.vmd\\'" . conf-mode))
             auto-mode-alist
             ))

(use-package! kotlin-mode
  :mode "\\.kt\\'")

(use-package! groovy-mode
  :mode "\\.groovy\\'")

(use-package! systemd
  :mode "\\.service\\'")

(use-package! dart-mode
  :mode "\\.dart\\'")

;; Load it
(use-package! salt-mode
  :config
;; Flyspell
(add-hook 'salt-mode-hook
        (lambda ()
            (flyspell-mode 1))))

;; Load it
(use-package! wolfram-mode
  :config
  (setq mathematica-command-line "~/.local/bin/mash")
  (add-to-list 'org-src-lang-modes '("mathematica" . wolfram)))

(use-package! snakemake-mode
  :mode "\\.smk"
  )
(after! snakemake-mode
  (set-formatter! 'snakefmt '("uvx" "snakefmt" "-") :modes '(snakemake-mode))
)

(use-package! capnp-mode
    :mode "\\.capnp")

(use-package! nushell-mode
    :mode "\\.nu")

(use-package! fish-mode
    :mode "\\.fish")

(use-package! nickel-mode
  :mode "\\.ncl"
  )
(after! nickel-mode
  (set-formatter! 'nickelfmt
    '("nickel" "format")
    :modes '(nickel-mode))
  )

(after! meson-mode
  (set-formatter! 'mesonfmt
    '("meson" "format")
    :modes '(meson-mode))
  )

pixi global add --environment r_env r-styler --expose pixiR=R

(set-formatter!
  'rstyler
  '("pixiR" "-s" "--no-save" "--no-restore" "-e" "styler::style_text(readLines(file('stdin')))")
  :modes '(ess-r-mode))

(use-package! essgd
  :after ess-r-mode
  :commands (essgd-start))

;; (setq treesit-language-source-alist
;;       '((astro "https://github.com/virchau13/tree-sitter-astro")
;;         (css "https://github.com/tree-sitter/tree-sitter-css")
;;         (tsx "https://github.com/tree-sitter/tree-sitter-typescript" "master" "tsx/src")))
;; (mapc #'treesit-install-language-grammar '(astro css tsx))
;; (use-package! astro-ts-mode
;;     :mode "\\.astro")

(use-package! dockerfile-mode
  :mode "Dockerfile\\'"
  :config
  (put 'dockerfile-image-name 'safe-local-variable #'stringp)
  )

(use-package! wakatime-mode
  :config
  (cond ((featurep :system 'linux) (setq wakatime-cli-path "/usr/bin/wakatime"))
        ((featurep :system 'macos) (setq wakatime-cli-path "/usr/local/bin/wakatime-cli")) ;; We assume homebrew
        )
  )

(define-minor-mode unpackaged/org-export-html-with-useful-ids-mode
  "Attempt to export Org as HTML with useful link IDs.
Instead of random IDs like \"#orga1b2c3\", use heading titles,
made unique when necessary."
  :global t
  (if unpackaged/org-export-html-with-useful-ids-mode
      (advice-add #'org-export-get-reference :override #'unpackaged/org-export-get-reference)
    (advice-remove #'org-export-get-reference #'unpackaged/org-export-get-reference)))

(defun unpackaged/org-export-get-reference (datum info)
  "Like `org-export-get-reference', except uses heading titles instead of random numbers."
  (let ((cache (plist-get info :internal-references)))
    (or (car (rassq datum cache))
        (let* ((crossrefs (plist-get info :crossrefs))
               (cells (org-export-search-cells datum))
               ;; Preserve any pre-existing association between
               ;; a search cell and a reference, i.e., when some
               ;; previously published document referenced a location
               ;; within current file (see
               ;; `org-publish-resolve-external-link').
               ;;
               ;; However, there is no guarantee that search cells are
               ;; unique, e.g., there might be duplicate custom ID or
               ;; two headings with the same title in the file.
               ;;
               ;; As a consequence, before re-using any reference to
               ;; an element or object, we check that it doesn't refer
               ;; to a previous element or object.
               (new (or (cl-some
                         (lambda (cell)
                           (let ((stored (cdr (assoc cell crossrefs))))
                             (when stored
                               (let ((old (org-export-format-reference stored)))
                                 (and (not (assoc old cache)) stored)))))
                         cells)
                        (when (org-element-property :raw-value datum)
                          ;; Heading with a title
                          (unpackaged/org-export-new-title-reference datum cache))
                        ;; NOTE: This probably breaks some Org Export
                        ;; feature, but if it does what I need, fine.
                        (org-export-format-reference
                         (org-export-new-reference cache))))
               (reference-string new))
          ;; Cache contains both data already associated to
          ;; a reference and in-use internal references, so as to make
          ;; unique references.
          (dolist (cell cells) (push (cons cell new) cache))
          ;; Retain a direct association between reference string and
          ;; DATUM since (1) not every object or element can be given
          ;; a search cell (2) it permits quick lookup.
          (push (cons reference-string datum) cache)
          (plist-put info :internal-references cache)
          reference-string))))

(defun unpackaged/org-export-new-title-reference (datum cache)
  "Return new reference for DATUM that is unique in CACHE."
  (cl-macrolet ((inc-suffixf (place)
                  `(progn
                     (string-match (rx bos
                                       (minimal-match (group (1+ anything)))
                                       (optional "--" (group (1+ digit)))
                                       eos)
                                   ,place)
                     ;; HACK: `s1' instead of a gensym.
                     (-let* (((s1 suffix) (list (match-string 1 ,place)
                                                (match-string 2 ,place)))
                             (suffix (if suffix
                                         (string-to-number suffix)
                                       0)))
                       (setf ,place (format "%s--%s" s1 (cl-incf suffix)))))))
    (let* ((title (org-element-property :raw-value datum))
           (ref (url-hexify-string (substring-no-properties title)))
           (parent (org-element-property :parent datum)))
      (while (--any (equal ref (car it))
                    cache)
        ;; Title not unique: make it so.
        (if parent
            ;; Append ancestor title.
            (setf title (concat (org-element-property :raw-value parent)
                                "--" title)
                  ref (url-hexify-string (substring-no-properties title))
                  parent (org-element-property :parent parent))
          ;; No more ancestors: add and increment a number.
          (inc-suffixf ref)))
      ref)))

; Pdf
(defun haozeke/org-save-and-export-pdf ()
  (if (eq major-mode 'org-mode)
    (org-latex-export-to-pdf :async t)))

(defun haozeke/org-save-and-export-koma-letter-pdf ()
  (if (eq major-mode 'org-mode)
    (org-koma-letter-export-to-pdf)))

; LaTeX
(defun haozeke/org-save-and-export-latex ()
  (interactive)
  (if (eq major-mode 'org-mode)
    (org-latex-export-to-latex t)))
(defun haozeke/org-save-and-export-beamer ()
  (interactive)
  (if (eq major-mode 'org-mode)
    (org-beamer-export-to-latex t)))

;; Kanged from https://emacs.stackexchange.com/a/51378/19155
(defun hz-clear-all-results ()
  "Clear all results in the buffer."
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (while (org-babel-next-src-block)
      (org-babel-remove-result))))

;; this function is used to append multiple elements to the list 'ox-latex
(defun append-to-list (list-var elements)
  "Append ELEMENTS to the end of LIST-VAR. The return value is the new value of LIST-VAR."
  (unless (consp elements) (error "ELEMENTS must be a list"))
  (let ((list (symbol-value list-var)))
    (if list
        (setcdr (last list) elements)
      (set list-var elements)))
(symbol-value list-var))

(defun async-shell-command-no-window
    (command)
  (interactive)
  (let
      ((display-buffer-alist
        (list
         (cons
          "\\*Async Shell Command\\*.*"
          (cons #'display-buffer-no-window nil)))))
    (async-shell-command
     command)))

(setq rustic-format-on-save t
      ;; rustfmt uses `--edition 2015` by default. For now, 2021 seems to be a
      ;; reasonable alternative.
      rustic-rustfmt-args "--edition 2021")

(defun haozeke/clang-format-buffer-conditional ()
(interactive)
  "Reformat buffer if .clang-format exists in the projectile root."
  (when (f-exists? (expand-file-name ".clang-format" (projectile-project-root)))
    (+format/buffer)))

(defun haozeke/org-pandoc-markdown (dir &optional pargs)
  "A wrapper to generate yaml metadata markdown files. Takes the output
  directory followed by pandoc arguments"
  (if (not (file-exists-p dir)) (make-directory dir))
  (async-shell-command-no-window
   (concat "pandoc -f org -t markdown -s " pargs " " (buffer-name) " -o "
           dir "/" (file-name-sans-extension (buffer-name)) ".md"))
    )

(defun export-as-workbench-md ()
  "Save, strip the export line via grep, and pipe to Pandoc."
  (interactive)
  (save-buffer)
  (let* ((src (buffer-file-name))
         ;; Get the filename from the buffer keywords
         (kv  (org-collect-keywords '("EXPORT_FILE_NAME")))
         (out (or (cadr (assoc "EXPORT_FILE_NAME" kv))
                  (concat (file-name-sans-extension src) ".md")))
         ;; Grep excludes the line -> Pipe -> Pandoc
         (cmd (format "grep -v '^#+EXPORT_FILE_NAME:' %s | pandoc -f org -t markdown-smart+fenced_divs -o %s"
                      (shell-quote-argument src)
                      (shell-quote-argument out))))

    (shell-command cmd)
    (message "Exported to %s" out)))

(defun sp-wrap-backtick ()
  "Wrap following sexp in backticks."
  (interactive)
  (sp-wrap-with-pair "`"))
(defun sp-wrap-tilda ()
  "Wrap following sexp in tildes."
  (interactive)
  (sp-wrap-with-pair "~"))

(defun sort-words (reverse beg end)
  "Sort words in region alphabetically, in REVERSE if negative.
Prefixed with negative \\[universal-argument], sorts in reverse.

The variable `sort-fold-case' determines whether alphabetic case
affects the sort order.

See `sort-regexp-fields'."
  (interactive "*P\nr")
  (sort-regexp-fields reverse "\\w+" "\\&" beg end))

(defun doom--doas-file-path (file)
  (let ((host (or (file-remote-p file 'host) "localhost")))
    (concat "/" (when (file-remote-p file)
                  (concat (file-remote-p file 'method) ":"
                          (if-let (user (file-remote-p file 'user))
                              (concat user "@" host)
                            host)
                          "|"))
            "doas:root@" host
            ":" (or (file-remote-p file 'localname)
                    file))))

(defun doom/doas-find-file (file &optional arg)
  "Open FILE as root.

This will prompt you to save the current buffer, unless prefix ARG is given, in
which case it will save it without prompting."
  (interactive
   (list (read-file-name "Open file as root: ")
         current-prefix-arg))
  ;; HACK: Teach `save-place' to treat the new "remote" buffer as if it were
  ;;   visiting the same local file (because it is), and preserve the cursor
  ;;   position as usual.
  (letf! ((defun remote-local-name (path)
            (if path (or (file-remote-p path 'localname) path)))
          (defmacro with-local-name (&rest body)
            `(when save-place-mode
               (let ((buffer-file-name (remote-local-name buffer-file-name))
                     (default-directory (remote-local-name default-directory)))
                 ,@body))))
    (let ((window-start (window-start))
          (buffer (current-buffer)))
      (when (and buffer-file-name (file-equal-p buffer-file-name file))
        (when (buffer-modified-p)
          (save-some-buffers arg (lambda () (eq (current-buffer) buffer))))
        (with-local-name (save-place-to-alist)))
      (prog1
          ;; HACK: Disable auto-save in temporary tramp buffers because it could
          ;;   trigger processes that hang silently in the background, making
          ;;   those buffers inoperable for the rest of that session (Tramp
          ;;   caches them).
          (let ((auto-save-default nil)
                ;; REVIEW: use only these when we drop 28 support
                (remote-file-name-inhibit-auto-save t)
                (remote-file-name-inhibit-auto-save-visited t)
                ;; Prevent redundant work
                save-place-mode)
            (find-file (doom--doas-file-path (expand-file-name file))))
        ;; Record of the cursor's old position if it isn't at BOB (indicating
        ;; this buffer was already open), in case the user wishes to go to it.
        (unless (bobp)
          (doom-set-jump-h)
          ;; save-place-find-file-hook requires point be a BOB to do its thang.
          (goto-char (point-min)))
        (with-local-name (save-place-find-file-hook))
        (set-window-start nil window-start)))))
(defun doom/doas-this-file ()
  "Open the current file as root on Alpine Linux."
  (interactive)
  (doom/doas-find-file
   (or (buffer-file-name (buffer-base-buffer))
       (when (or (derived-mode-p 'dired-mode)
                 (derived-mode-p 'wdired-mode))
         default-directory)
       (user-error "Current buffer isn't visiting a file"))))

(defun doom/doas-save-buffer ()
  "Save this file as root on Alpine Linux."
  (interactive)
  (let ((file (doom--doas-file-path (buffer-file-name (buffer-base-buffer)))))
    (if-let (buffer (find-file-noselect file))
        (let ((origin (current-buffer)))
          (copy-to-buffer buffer (point-min) (point-max))
          (unwind-protect
              (with-current-buffer buffer
                (save-buffer))
            (unless (eq origin buffer)
              (kill-buffer buffer))
            (with-current-buffer origin
              (revert-buffer t t))))
      (user-error "Unable to open %S" file))))

;; (use-package! matrix-client
;;   :init
;;   :commands matrix-client-connect)

; dotdoom publishing
; This is a rather harmless useful variable
(setq dotdoom-root-dir "~/.config/doom/")
(setq dotdoom-publish-dir  (concat dotdoom-root-dir "docs"))

(use-package! firestarter
  :init
  (firestarter-mode)
  :config
  (setq firestarter-default-type t)
)

;; Save on focus lost (The frame's focus that is...)
;; (defun save-all ()
;;   (interactive)
;;   (save-some-buffers t))
;; (add-hook 'focus-out-hook 'save-all)

; rtags support was removed from Doom; this hook no longer exists
;; (remove-hook 'c-mode-common-hook #'+cc|init-rtags)

;; Compiler -- tectonic handles bibtex, package downloads, and multiple passes
(setq org-latex-pdf-process (list "tectonic -X compile --synctex --keep-logs %f"))

;; engrave-faces replaces minted for code highlighting
(setq org-latex-src-block-backend 'engraved)
(setq org-latex-engraved-theme t) ;; use current Emacs theme

(add-to-list 'org-latex-classes
             '("koma-article" "\\documentclass{scrartcl}"
               ("\\section{%s}" . "\\section*{%s}")
               ("\\subsection{%s}" . "\\subsection*{%s}")
               ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
               ("\\paragraph{%s}" . "\\paragraph*{%s}")
               ("\\subparagraph{%s}" . "\\subparagraph*{%s}")))

(add-to-list 'org-latex-classes
             '("koma-report" "\\documentclass{scrreprt}"))

(append-to-list
 'org-latex-classes
 '(("tufte-book"
    "\\documentclass[a4paper, sfsidenotes, openany, justified]{tufte-book}"
    ("\\part{%s}" . "\\part*{%s}")
    ("\\chapter{%s}" . "\\chapter*{%s}")
    ("\\section{%s}" . "\\section*{%s}")
    ("utf8" . "utf8x")
    ("\\subsection{%s}" . "\\subsection*{%s}"))))

(defun org-babel-execute:rst (body params)
  "Execute a block of rst code with org-babel.
This function is called by `org-babel-execute-src-block'."
  (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
         (in-file (org-babel-temp-file "rst-"))
         (cmdline (cdr (assoc :cmdline params)))
         (to (cdr (assoc :to params)))
         (template (cdr (assoc :template params)))
         (cmd (concat "pandoc"
                      " -t  org"
                      " -i " (org-babel-process-file-name in-file)
                      " -f rst "
                      " " cmdline)))
    (with-temp-file in-file (insert body))
    (message cmd)
    (shell-command-to-string cmd))) ;; Send to results

(defun org-babel-prep-session:rst (session params)
  "Return an error because rst does not support sessions."
  (error "rst does not support sessions"))

(defun org-babel-execute:mdhtml (body params)
  "Execute a block of rst code with org-babel.
This function is called by `org-babel-execute-src-block'."
  (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
         (in-file (org-babel-temp-file "mdhtml-"))
         (cmdline (cdr (assoc :cmdline params)))
         (to (cdr (assoc :to params)))
         (template (cdr (assoc :template params)))
         (cmd (concat "pandoc"
                      " -t  html"
                      " -i " (org-babel-process-file-name in-file)
                      " -f gfm "
                      " " cmdline)))
    (with-temp-file in-file (insert body))
    (message cmd)
    (shell-command-to-string cmd))) ;; Send to results

(defun org-babel-prep-session:mdhtml (session params)
  "Return an error because mdhtml does not support sessions."
  (error "mdhtml does not support sessions"))

(use-package! flycheck-package
  :after flycheck
  :config (flycheck-package-setup))

(use-package! citar
  :commands (citar-insert-citation
             citar-insert-reference
             citar-open
             citar-capf-setup)
  :init
  (setq org-cite-global-bibliography (list zot_bib)
        org-cite-insert-processor 'citar
        org-cite-follow-processor 'citar
        org-cite-activate-processor 'citar
        citar-bibliography org-cite-global-bibliography)
  :hook ((org-mode . citar-capf-setup)
         (LaTeX-mode . citar-capf-setup)
         (latex-mode . citar-capf-setup))
  :config
  (rg/bibtex-configure-paths)
  (setq org-cite-global-bibliography (list zot_bib)
        citar-bibliography org-cite-global-bibliography
        citar-at-point-function 'embark-act))

(use-package! citar-embark
  :after (citar embark)
  :config
  (citar-embark-mode))

(use-package! org-ref
  :init
  (with-eval-after-load 'ox
    (defun my/org-ref-process-buffer--html (backend)
      "Preprocess `org-ref' citations to HTML format.

  Do this only if the export backend is `html' or a derivative of
  that."
      ;; `ox-hugo' is derived indirectly from `ox-html'.
      ;; ox-hugo <- ox-blackfriday <- ox-md <- ox-html
      (when (org-export-derived-backend-p backend 'html)
        (org-ref-process-buffer 'html)))
    (add-to-list 'org-export-before-parsing-hook #'my/org-ref-process-buffer--html))
  :config
  (rg/bibtex-configure-paths)
  (setq
   org-ref-get-pdf-filename-function 'org-ref-get-pdf-filename-helm-bibtex
   bibtex-completion-bibliography (list zot_bib)
   bibtex-completion-notes-path (expand-file-name "bibnotes.org" org_notes)
   org-ref-note-title-format "* TODO %y - %t\n :PROPERTIES:\n  :Custom_ID: %k\n  :NOTER_DOCUMENT: %F\n :ROAM_KEY: cite:%k\n  :AUTHOR: %9a\n  :JOURNAL: %j\n  :YEAR: %y\n  :VOLUME: %v\n  :PAGES: %p\n  :DOI: %D\n  :URL: %U\n :END:\n\n"
   org-ref-notes-directory org_notes
   org-ref-notes-function 'orb-edit-notes
   ))

(after! org-ref
  (setq
   bibtex-completion-notes-path org_notes
   bibtex-completion-bibliography zot_bib
   bibtex-completion-pdf-field "file"
   bibtex-completion-notes-template-multiple-files
   (concat
    "#+TITLE: ${title}\n"
    "#+ROAM_KEY: cite:${=key=}\n"
    "#+ROAM_TAGS: ${keywords}\n"
    "* TODO Notes\n"
    ":PROPERTIES:\n"
    ":Custom_ID: ${=key=}\n"
    ":NOTER_DOCUMENT: %(orb-process-file-field \"${=key=}\")\n"
    ":AUTHOR: ${author-abbrev}\n"
    ":JOURNAL: ${journaltitle}\n"
    ":DATE: ${date}\n"
    ":YEAR: ${year}\n"
    ":DOI: ${doi}\n"
    ":URL: ${url}\n"
    ":END:\n\n"
    )
   )
  )

(use-package! org-roam-bibtex
  :after (org-roam)
  :hook (org-roam-mode . org-roam-bibtex-mode)
  :config
  (setq org-roam-bibtex-preformat-keywords
        '("=key=" "title" "url" "file" "author-or-editor" "keywords"))
  (setq orb-templates
        '(("r" "ref" plain (function org-roam-capture--get-point)
           ""
           :file-name "${slug}"
           :head "#+TITLE: ${=key=}: ${title}\n#+ROAM_KEY: ${ref}\n#+ROAM_TAGS:

- keywords :: ${keywords}

\n* ${title}\n  :PROPERTIES:\n  :Custom_ID: ${=key=}\n  :URL: ${url}\n  :AUTHOR: ${author-or-editor}\n  :NOTER_DOCUMENT: %(orb-process-file-field \"${=key=}\")\n  :NOTER_PAGE: \n  :END:\n\n"

           :unnarrowed t))))

(use-package! org-noter
  :after (:any org pdf-view)
  :init
  (setq org-noter-supported-modes '(doc-view-mode pdf-view-mode))
  :config
  (setq
   ;; The WM can handle splits
   org-noter-notes-window-location 'other-frame
   ;; Please stop opening frames
   org-noter-always-create-frame nil
   ;; I want to see the whole file
   org-noter-hide-other nil
   ;; Everything is relative to the rclone mega
   org-noter-notes-search-path (list org_notes)
   )
  )

(set-popup-rule! "^CAPTURE-.*\\.org$" :size 0.5 :quit nil :select t :autosave t)

;; Fix some link issues
(defun transform-square-brackets-to-round-ones(string-to-transform)
  "Transforms [ into ( and ] into ), other chars left unchanged."
  (concat
   (mapcar #'(lambda (c) (if (equal c ?\[) ?\( (if (equal c ?\]) ?\) c))) string-to-transform))
  )

;; Actually start using templates
(after! org-capture
  ;; Firefox
  (add-to-list 'org-capture-templates
               '("P" "Protocol" entry
                 (file+headline +org-capture-notes-file "Inbox")
                 "* %^{Title}\nSource: %u, %c\n #+BEGIN_QUOTE\n%i\n#+END_QUOTE\n\n\n%?"
                 :prepend t
                 :kill-buffer t))
  (add-to-list 'org-capture-templates
               '("L" "Protocol Link" entry
                 (file+headline +org-capture-notes-file "Inbox")
                 "* %? [[%:link][%(transform-square-brackets-to-round-ones \"%:description\")]]\n"
                 :prepend t
                 :kill-buffer t))
  ;; Misc
  (add-to-list 'org-capture-templates
               '("a"               ; key
                 "Article"         ; name
                 entry             ; type
                 (file+headline +org-capture-notes-file "Article")  ; target
                 "* %^{Title} %(org-set-tags)  :article: \n:PROPERTIES:\n:Created: %U\n:Linked: %a\n:END:\n%i\nBrief description:\n%?"  ; template
                 :prepend t        ; properties
                 :empty-lines 1    ; properties
                 :created t        ; properties
                 ))
  )