Literate doom-emacs config

(setq doom-font (font-spec :family "Intel One Mono" :size 18))
;; (setq doom-font (font-spec :family "Attribute Mono" :size 16))
(unless (find-font doom-font)
  (setq doom-font (font-spec :family "Cascadia Code PL" :size 14)))

(setq doom-unicode-font (font-spec :family "Symbola" :size 20))

;; Undo the helm text enlargement in childframes
(setq +helm-posframe-text-scale 0)

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

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

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

(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
                                          ))

(use-package! general)
;; Creating a constant for making future changes simpler
(defconst my-leader "SPC")
;; Tell general all about it
(general-create-definer my-leader-def
  :prefix my-leader)
  ;; :prefix my-leader)
;; (general-create-definer my-local-leader-def
;;   ;; :prefix my-local-leader
;;   :prefix "SPC m")

;; 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
          )
        )
 )

(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")
;; All the find commands
"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" '(helm-insert-latex-math :wk "Math Symbols")
  "m i r" '(:ignore t :wk "References")
  "m i r h" '(helm-bibtex-with-local-bibliography :wk "Helm")
  "m i r r" '(reftex-citation :wk "Reftex")
  )

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

(cond ((featurep :system 'macos) (custom-set-variables '(epg-gpg-program "/usr/local/bin/gpg")) ;; brew
              (setq exec-path (append exec-path '("/run/current-system/sw/bin"))) ;; nix
              (setq exec-path (append exec-path '("/usr/local/bin/"))) ;; brew
              ))

(use-package! epa-file
  :demand
  :config
  (epa-file-enable)
    (load (concat doom-private-dir "local/private.el.gpg"))
  )

(setq org-export-async-init-file (concat doom-private-dir "local/async-ox.el"))

  (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/")
    )

(after! eglot
  :config
  (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 '("pylsp"))
  (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")
                                      )))
    )
  )

;; 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
  (setq spell-fu-idle-delay 0.5 ; default is 0.25
        ispell-program-name "hunspell"
        ;; aspell -> "--sug-mode=ultra"
        ;;ispell-extra-args '("-d en_US")
        ispell-dictionary "en_US" ; needed for MacOS in particular
        ispell-personal-dictionary "~/.aspell.en.pws" ; standard location
        spell-fu-dictionary "~/.config/dict" ; standard location
        )
  ;; use American English as ispell default dictionary
  (ispell-change-dictionary "american" t)
  (setq-default ispell-program-name "hunspell")
)

;; 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)

(setq  inferior-julia-program-name "/bin/julia")

;; 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 (string-match-p "wayland" (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! 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! helm-org-rifle
  :after org
  :general
  (:keymaps 'org-mode-map
            :states 'normal
            :prefix my-leader
            "m r" '(:ignore t :wk "Rifle (Helm)")
            "m r b" '(helm-org-rifle-current-buffer :wk "Rifle buffer")
            "m r e" '(helm-org-rifle :wk "Rifle every open buffer")
            "m r d" '(helm-org-rifle-directory :wk "Rifle from org-directory")
            "m r a" '(helm-org-rifle-agenda-files :wk "Rifle agenda")
            "m r o" '(:ignore t :wk "Occur (Persistent)")
            "m r o b" '(helm-org-rifle-current-buffer :wk "Rifle buffer")
            "m r o e" '(helm-org-rifle :wk "Rifle every open buffer")
            "m r o d" '(helm-org-rifle-directory :wk "Rifle from org-directory")
            "m r o a" '(helm-org-rifle-agenda-files :wk "Rifle agenda")
            )
  )

(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-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)

(setq org-hugo-auto-set-lastmod 't
      org-hugo-section "posts"
      org-hugo-suppress-lastmod-period 43200.0
      org-hugo-export-creator-string "Emacs 26.3 (Org mode 9.4 + ox-hugo + HaoZeke)"
)

(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
  (add-hook!'meson-mode-hook 'company-mode)
  )

(use-package! xonsh-mode
  :mode "\\.xsh\\'"
  :config
  (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
    :config
  (add-to-list 'auto-mode-alist '("\\.smk" . snakemake-mode)))

(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)))

;; 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 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))

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

; dotDoom stuff
; 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)

; Do not automatically try to run rdm
(remove-hook 'c-mode-common-hook #'+cc|init-rtags)

;; Compiler
(setq org-latex-pdf-process (list "latexmk -shell-escape -f -pdfxe %f"))

;; Configuration
(add-to-list 'org-latex-packages-alist '("" "minted" "xcolor"))
(setq org-latex-listings 'minted)
(setq org-latex-minted-options
  '(("bgcolor" "white") ("breaklines" "true") ("linenos" "true") ("style" "tango")))

(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"))

;; accept completion from copilot and fallback to company
;; (use-package! copilot
;;   :hook (prog-mode . copilot-mode)
;;   :bind (:map copilot-completion-map
;;               ("<tab>" . 'copilot-accept-completion)
;;               ("TAB" . 'copilot-accept-completion)
;;               ("C-TAB" . 'copilot-accept-completion-by-word)
;;               ("C-<tab>" . 'copilot-accept-completion-by-word)))

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

(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
    (setq
         org-ref-completion-library 'org-ref-ivy-cite
         org-ref-get-pdf-filename-function 'org-ref-get-pdf-filename-helm-bibtex
         bibtex-completion-bibliography (list (concat (getenv "HOME") "/GDrive/zotLib.bib"))
         bibtex-completion-notes-path (concat (getenv "HOME") "/Git/Gitlab/Mine/Notes/bibnotes.org")
         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 (concat (getenv "HOME") "/Git/Gitlab/Mine/Notes/")
         org-ref-notes-function 'orb-edit-notes
    ))

(after! org-ref
  (setq
   bibtex-completion-notes-path (concat (getenv "HOME") "/Git/Gitlab/Mine/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)
  :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))
  )