(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 native-comp-async-report-warnings-errors 'silent)

(setq warning-minimum-level :error)

(require 'package)
(setq package-archives '(("elpa" . "https://elpa.gnu.org/packages/")
                         ("melpa" . "https://melpa.org/packages/")
                         ("org" . "https://orgmode.org/elpa/")))
(package-initialize)
(unless package-archive-contents (package-refresh-contents))

(unless (package-installed-p 'use-package) (package-install 'use-package))
(require 'use-package)
(setq use-package-always-ensure t)

(use-package no-littering
  :config
  (no-littering-theme-backups)
  (setq auto-save-file-name-transforms
        `((".*" ,(no-littering-expand-var-file-name "auto-save/") t))))

(add-to-list 'default-frame-alist '(fullscreen . maximized))

(setq inhibit-startup-screen t
      initial-scratch-message nil)

(tool-bar-mode -1)
(menu-bar-mode -1)
(scroll-bar-mode -1)

(column-number-mode)

(add-hook 'prog-mode-hook #'show-paren-mode)

(global-hl-line-mode)

(recentf-mode)
(save-place-mode)
(savehist-mode)

(setq history-length 256)

(add-to-list 'recentf-exclude (format "%s/\\.emacs\\.d/elpa/.*" (getenv "HOME")))
(add-to-list 'recentf-exclude
             (recentf-expand-file-name no-littering-var-directory))
(add-to-list 'recentf-exclude
             (recentf-expand-file-name no-littering-etc-directory))

(add-hook 'before-save-hook 'delete-trailing-whitespace)

(setq require-final-newline t)

(global-auto-revert-mode)

(setq-default tab-width 2
              indent-tabs-mode nil)

(global-set-key (kbd "C-x <up>") 'windmove-up)
(global-set-key (kbd "C-x <down>") 'windmove-down)
(global-set-key (kbd "C-x <left>") 'windmove-left)
(global-set-key (kbd "C-x <right>") 'windmove-right)

(delete-selection-mode 1)

(setq split-width-threshold 170
      split-height-threshold nil)

(setq confirm-kill-emacs 'y-or-n-p)

(setq dired-listing-switches "-alFh")

(setq global-auto-revert-non-file-buffers t)

(set-frame-parameter nil 'alpha-background 85) ; For current frame
(add-to-list 'default-frame-alist '(alpha-background . 85)) ; For all new frames henceforth
(defun yr/toggle-window-transparency ()
  "Toggle frame's background transparency."
  (interactive)
  (let* ((desired-alpha 85)) (set-frame-parameter nil 'alpha-background (if (not (frame-parameter nil 'alpha-background)) desired-alpha))))

(use-package dracula-theme
  :init
  (if (display-graphic-p)
    (load-theme 'dracula t)))

(use-package vertico
  :init
  (vertico-mode)
  (setq vertico-count 3)  ;; Customize number of candidates shown
  )

(use-package marginalia
  ;; Bind `marginalia-cycle' locally in the minibuffer.  To make the binding
  ;; available in the *Completions* buffer, add it to `completion-list-mode-map'.
  :bind (:map minibuffer-local-map
         ("M-A" . marginalia-cycle))
  ;; The :init configuration is always executed (Not lazy!)
  :init
  ;; Must be in the :init section of use-package such that the mode gets
  ;; enabled right away. Note that this forces loading the package.
  (marginalia-mode))

(use-package which-key
  :init
  (which-key-mode)
  :config
  (setq which-key-separator ": ")) ;; change seperator to fix vertical spacing issues

(use-package corfu
  :custom
  (corfu-auto t)  ;; Enable showing autocompletion automatically
  (corfu-cycle t) ;; Enable cycling for `corfu-next/previous'
  :init
  (global-corfu-mode))

(use-package cape
  ;; Bind dedicated completion commands
  ;; Alternative prefix keys: C-c p, M-p, M-+, ...
  :bind (("C-c p p" . completion-at-point) ;; capf
         ("C-c p t" . complete-tag)        ;; etags
         ("C-c p d" . cape-dabbrev)        ;; or dabbrev-completion
         ("C-c p h" . cape-history)
         ("C-c p f" . cape-file)
         ("C-c p k" . cape-keyword)
         ("C-c p s" . cape-symbol)
         ("C-c p a" . cape-abbrev)
         ("C-c p l" . cape-line)
         ("C-c p w" . cape-dict)
         ("C-c p \\" . cape-tex)
         ("C-c p _" . cape-tex)
         ("C-c p ^" . cape-tex)
         ("C-c p &" . cape-sgml)
         ("C-c p r" . cape-rfc1345))
  :init
  ;; Add `completion-at-point-functions', used by `completion-at-point'.
  ;; NOTE: The order matters!
  (add-to-list 'completion-at-point-functions #'cape-dabbrev)
  (add-to-list 'completion-at-point-functions #'cape-file)
  ;; (add-to-list 'completion-at-point-functions #'cape-elisp-block)
  ;;(add-to-list 'completion-at-point-functions #'cape-history)
  ;;(add-to-list 'completion-at-point-functions #'cape-keyword)
  ;;(add-to-list 'completion-at-point-functions #'cape-tex)
  ;;(add-to-list 'completion-at-point-functions #'cape-sgml)
  ;;(add-to-list 'completion-at-point-functions #'cape-rfc1345)
  ;;(add-to-list 'completion-at-point-functions #'cape-abbrev)
  ;;(add-to-list 'completion-at-point-functions #'cape-dict)
  ;;(add-to-list 'completion-at-point-functions #'cape-symbol)
  ;;(add-to-list 'completion-at-point-functions #'cape-line)
)

(use-package orderless
  :init
  (setq completion-styles '(orderless basic)
        completion-category-overrides '((file (styles partial-completion)))))

(use-package prescient
  :after vertico)
(use-package vertico-prescient
  :after prescient
  :init
  (vertico-prescient-mode))
(use-package corfu-prescient
  :after prescient
  :init
  (corfu-prescient-mode))

;; Example configuration for Consult
(use-package consult
  ;; Replace bindings. Lazily loaded due 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 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-flycheck)              ;; Alternative: consult-flymake
         ("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-fd)                    ;; Alternative: consult-find
         ("M-s D" . consult-locate)
         ("M-s g" . consult-grep)
         ("M-s G" . consult-git-grep)
         ("M-s r" . consult-ripgrep)
         ("M-s l" . 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-bookmark consult-recent-file consult-xref
   consult--source-bookmark consult--source-file-register
   consult--source-recent-file consult--source-project-recent-file
   ;; :preview-key "M-."
   :preview-key '(:debounce 0.4 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.
  ;; (define-key consult-narrow-map (vconcat consult-narrow-key "?") #'consult-narrow-help)

  ;; By default `consult-project-function' uses `project-root' from project.el.
  ;; Optionally configure a different project root function.
  ;;;; 1. project.el (the default)
  ;; (setq consult-project-function #'consult--default-project--function)
  ;;;; 2. vc.el (vc-root-dir)
  ;; (setq consult-project-function (lambda (_) (vc-root-dir)))
  ;;;; 3. locate-dominating-file
  ;; (setq consult-project-function (lambda (_) (locate-dominating-file "." ".git")))
  ;;;; 4. projectile.el (projectile-project-root)
  ;; (autoload 'projectile-project-root "projectile")
  ;; (setq consult-project-function (lambda (_) (projectile-project-root)))
  ;;;; 5. No project support
  ;; (setq consult-project-function nil)
)

(use-package embark
  :ensure t
  :bind
  (("C-." . embark-act)         ;; pick some comfortable binding
   ("C-;" . embark-dwim)        ;; good alternative: M-.
   ("C-h B" . embark-bindings)) ;; alternative for `describe-bindings'

  :init
  ;; Optionally replace the key help with a completing-read interface
  (setq prefix-help-command #'embark-prefix-help-command)

  (defun embark-which-key-indicator ()
    "An embark indicator that displays keymaps using which-key.
The which-key help message will show the type and value of the
current target followed by an ellipsis if there are further
targets."
    (lambda (&optional keymap targets prefix)
      (if (null keymap)
          (which-key--hide-popup-ignore-command)
        (which-key--show-keymap
         (if (eq (plist-get (car targets) :type) 'embark-become)
             "Become"
           (format "Act on %s '%s'%s"
                   (plist-get (car targets) :type)
                   (embark--truncate-target (plist-get (car targets) :target))
                   (if (cdr targets) "…" "")))
         (if prefix
             (pcase (lookup-key keymap prefix 'accept-default)
               ((and (pred keymapp) km) km)
               (_ (key-binding prefix 'accept-default)))
           keymap)
         nil nil t (lambda (binding)
                     (not (string-suffix-p "-argument" (cdr binding))))))))

  (setq embark-indicators
        '(embark-which-key-indicator
          embark-highlight-indicator
          embark-isearch-highlight-indicator))

  (defun embark-hide-which-key-indicator (fn &rest args)
    "Hide the which-key indicator immediately when using the completing-read prompter."
    (which-key--hide-popup-ignore-command)
    (let ((embark-indicators
           (remq #'embark-which-key-indicator embark-indicators)))
      (apply fn args)))

  (advice-add #'embark-completing-read-prompter
              :around #'embark-hide-which-key-indicator)

  :config
  ;; Hide the mode line of the Embark live/completions buffers
  (add-to-list 'display-buffer-alist
               '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
                 nil
                 (window-parameters (mode-line-format . none)))))

(use-package embark-consult
  :ensure t ; only need to install it, embark loads it after consult if found
  :hook
  (embark-collect-mode . consult-preview-at-point-mode))

(use-package jinx
  :hook (emacs-startup . global-jinx-mode)
  :after tex
  :bind ([remap ispell-word] . jinx-correct))

(setq vertico-multiform-categories '((jinx grid) (vertico-grid-annotate . 36)))
(vertico-multiform-mode 1)

(use-package dashboard
  :config
  (dashboard-setup-startup-hook)    ;; open dashboard on startup
  (setq dashboard-center-content t) ;; center dashboard
  (setq dashboard-startupify-list '(dashboard-insert-items)) ;; only show items in dashboard
  (setq dashboard-items '((bookmarks . 12)   ;; show 12 bookmarks
                          (recents  . 36)))) ;; show 36 recent files

(use-package doom-modeline
  :init
  (doom-modeline-mode 1))

(use-package prism
  :after julia-mode
  :hook (julia-mode . prism-whitespace-mode)) ;; auto-activate in julia-mode

(use-package dired-subtree
  :after dired
  :bind (:map dired-mode-map
              ("<tab>" . dired-subtree-toggle)
              ("<C-tab>" . dired-subtree-cycle)))

(use-package casual-dired
  :after dired
  :bind (:map dired-mode-map
              ("?" . 'casual-dired-tmenu)))

(use-package casual-bookmarks
  :bind (:map bookmark-mode-map ("?" . 'casual-bookmarks-tmenu)))

(use-package openwith
  :config
  (setq openwith-associations
        (list
         (list (openwith-make-extension-regexp
                '("doc" "xls" "ppt" "odt" "ods" "odg" "odp"))
               "libreoffice"
               '(file))
         ))
  :init
  (openwith-mode 1))

(use-package buffer-move
  :bind
  (("C-x C-<up>" . buf-move-up)
   ("C-x C-<down>" . buf-move-down)
   ("C-x C-<left>" . buf-move-left)
   ("C-x C-<right>" . buf-move-right)))

(use-package powerthesaurus
  :commands powerthesaurus-transient) ;; defer loading after powerthesaurus-transient is called

(use-package go-translate
  :commands gts-do-translate  ;; defer loading until gts-do-translate is called
  :config
  (setq gt-langs '(en fr))
  (setq gt-default-translator (gt-translator :engines (gt-google-engine))))

(defun my/org-copy-special ()
  "Copy the current region using `org-copy-special` and deactivate the mark."
  (interactive)
  (org-copy-special)
  (deactivate-mark))
(use-package org
  :mode
  ("\\.org\\'" . org-mode) ;; defer loading and auto-activate when .org file is opened
  :bind (:map org-mode-map
              ("C-c C-x M-w" . my/org-copy-special))
  :config
  (setq org-startup-indented t
        org-startup-truncated nil
        org-ellipsis " ▾"
        org-src-tab-acts-natively t       ;; enable indentation in source blocks
        org-support-shift-select 'always  ;; allow shift select
        org-image-actual-width nil)       ;; allow rescaling of images

  (setq org-preview-latex-default-process 'dvisvgm)
  (setq org-format-latex-options (plist-put org-format-latex-options :scale 1.1))
  (defun my/text-scale-adjust-latex-previews ()
    "Adjust the size of latex preview fragments when changing the buffer's text scale."
    (pcase major-mode
      ('latex-mode
       (dolist (ov (overlays-in (point-min) (point-max)))
         (if (eq (overlay-get ov 'category)
                 'preview-overlay)
             (my/text-scale--resize-fragment ov))))
      ('org-mode
       (dolist (ov (overlays-in (point-min) (point-max)))
         (if (eq (overlay-get ov 'org-overlay-type)
                 'org-latex-overlay)
             (my/text-scale--resize-fragment ov))))))

  (defun my/text-scale--resize-fragment (ov)
    (overlay-put
     ov 'display
     (cons 'image
           (plist-put
            (cdr (overlay-get ov 'display))
            :scale (+ 1.0 (* 0.3 text-scale-mode-amount))))))

  (add-hook 'text-scale-mode-hook #'my/text-scale-adjust-latex-previews))

(use-package org-modern
  :after org                   ;; defer loading after org
  :hook
  (org-mode . org-modern-mode) ;; auto-activate in org-mode
)

(use-package org-present
  :after org
  :config
  (define-key org-present-mode-keymap [right] nil) ;; undo binding right key
  (define-key org-present-mode-keymap [left] nil)  ;; undo binding left key
  (define-key org-present-mode-keymap (kbd "<next>") 'org-present-next)   ;; bind next slide to pageup
  (define-key org-present-mode-keymap (kbd "<prior>") 'org-present-prev)) ;; bind previous slide to pagedown

(use-package visual-fill-column
  :init
  ;; Configure fill width
  (setq visual-fill-column-width 120
        visual-fill-column-center-text t)

  (defun my/org-present-start ()
    ;; Center the presentation and wrap lines
    (visual-fill-column-mode 1)
    (visual-line-mode 1))

  (defun my/org-present-end ()
    ;; Stop centering the document
    (visual-fill-column-mode 0)
    (visual-line-mode 0))

  (add-hook 'org-present-mode-hook 'my/org-present-start)
  (add-hook 'org-present-mode-quit-hook 'my/org-present-end))

  ;; Register hooks with org-present
  ;; :hook
  ;; (org-present-mode-hook . my/org-present-start)
  ;; (org-present-mode-quit-hook . my/org-present-end))

(use-package denote
  :hook
  (dired-mode . denote-dired-mode)    ;; file highlighting in dired
  :config
  (setq denote-directory "~/notes/"))

(use-package magit
  :commands magit-status) ;; defer loading until magit-status is called

(use-package forge
  :after magit) ;; defer loading until magit is loaded
(setq auth-sources '("~/.authinfo.gpg"))

(setq explicit-shell-file-name "/bin/bash"
      shell-file-name "bash"
      explicit-bash.exe-args '("--noediting" "--login" "-ic")
      shell-command-switch "-ic")
(setenv "SHELL" shell-file-name)

(use-package tex
  :ensure auctex
  :mode
  ("\\.tex\\'" . latex-mode)
  :hook
  (LaTeX-mode . reftex-mode)      ;; always load reftex
  (LaTeX-mode . turn-on-flyspell) ;; always load flyspell
  (LaTeX-mode . TeX-fold-mode)    ;; always enable folding
  :init
  (setq TeX-parse-self t ;; auto-parse tex file on load
        TeX-auto-save t  ;; auto-parse tex file on save
        TeX-master nil)  ;; always query for master file
  (add-hook 'TeX-after-compilation-finished-functions #'TeX-revert-document-buffer)
  :config
  (setq TeX-view-program-selection '((output-pdf "PDF Tools"))
        TeX-view-program-list '(("PDF Tools" TeX-pdf-tools-sync-view))
        TeX-source-correlate-mode t
        TeX-source-correlate-start-server t)
  <<tex-custom-highlighting>>
  <<tex-custom-verbatim-environments>>
  <<tex-custom-spellcheck-blacklist-macros>>
  <<tex-custom-spellcheck-blacklist-environments>>
  <<tex-custom-query-labels>>
  <<tex-custom-folding>>
  )

(setq font-latex-match-reference-keywords
      '(("cref" "{")))

(eval-after-load 'latex '(add-to-list 'LaTeX-verbatim-environments "lstlisting"))

(setq flyspell-tex-command-regexp
      "\\(\\(begin\\|end\\)[ \t]*{\\|\\(cite[a-z*]*\\|label\\|ref\\|cref\\|eqref\\|usepackage\\|documentclass\\|input\\)[ \t]*\\(\\[[^]]*\\]\\)?{[^{}]*\\)")

(put 'LaTeX-mode 'flyspell-mode-predicate 'auctex-mode-flyspell-skip-myenv)
(defun auctex-mode-flyspell-skip-myenv ()
  (save-excursion
    (widen)
    (let ((p (point))
          (count 0))
      (not (or (and (re-search-backward "\\\\begin{\\(tikzpicture\\|lstlisting\\|myenv3\\)}" nil t)
                    (> p (point))
                    (or (not (re-search-forward "^\\\\end{\\(tikzpicture\\|lstlisting\\|myenv3\\)}" nil t))
                        (< p (point))))
               (eq 1 (progn (while (re-search-backward "`" (line-beginning-position) t)
                              (setq count (1+ count)))
                            (- count (* 2 (/ count 2))))))))))
(add-hook 'LaTeX-mode-hook (lambda () (setq flyspell-generic-check-word-predicate
                                            'auctex-mode-flyspell-skip-myenv)))

(setq reftex-label-alist
      '(("convention" ?d "con:" "~\\ref{%s}" t  ("convention" "con."))
        ("corollary" ?p "cor:" "~\\ref{%s}" t  ("corollary" "cor."))
        ("definition" ?d "def:" "~\\ref{%s}" t  ("definition" "def."))
        ("example" ?x "ex:" "~\\ref{%s}" t  ("example" "ex."))
        ("lemma" ?p "lem:" "~\\ref{%s}" t  ("lemma" "lem."))
        ("proposition" ?p "prop:" "~\\ref{%s}" t  ("proposition" "prop."))
        ("remark" ?x "rem:" "~\\ref{%s}" t  ("remark" "rem."))
        ("theorem" ?p "thm:" "~\\ref{%s}" t ("theorem" "thm."))))
(add-hook 'LaTeX-mode-hook
          (lambda ()
            (LaTeX-add-environments
             '("convention" LaTeX-env-label)
             '("corollary" LaTeX-env-label)
             '("definition" LaTeX-env-label)
             '("example" LaTeX-env-label)
             '("lemma" LaTeX-env-label)
             '("proposition" LaTeX-env-label)
             '("remark" LaTeX-env-label)
             '("theorem" LaTeX-env-label))
            (add-to-list 'LaTeX-label-alist '("convention" . "con:"))
            (add-to-list 'LaTeX-label-alist '("corollary" . "cor:"))
            (add-to-list 'LaTeX-label-alist '("definition" . "def:"))
            (add-to-list 'LaTeX-label-alist '("example" . "ex:"))
            (add-to-list 'LaTeX-label-alist '("lemma" . "lem:"))
            (add-to-list 'LaTeX-label-alist '("proposition" . "prop:"))
            (add-to-list 'LaTeX-label-alist '("remark" . "rem:"))
            (add-to-list 'LaTeX-label-alist '("theorem" . "thm:"))))

(defun TeX-fold-all ()
  (interactive)
  (let ((env (read-from-minibuffer "Environment: ")))
    (save-excursion
      (goto-char (point-min))
      (while (search-forward (format "begin{%s}" env) nil t)
        (TeX-fold-env)))))
(defun TeX-unfold-all ()
  (interactive)
  (let ((env (read-from-minibuffer "Environment: ")))
    (save-excursion
      (goto-char (point-min))
      (while (search-forward (format "begin{%s}" env) nil t)
        (TeX-fold-clearout-item)))))

(defun my-reftex-goto-label ()
  "Wrapper around reftex-goto-label with jump back functionality."
  (interactive)
  (push-mark)
  (reftex-goto-label))

(use-package company-math
  :after tex
  :init
  (defun math-setup-capf ()
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-math-symbols-latex))
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-math-symbols-unicode))
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-latex-commands)))
  :hook
  (LaTeX-mode . math-setup-capf))

(use-package company-reftex
  :after tex
  :init
  (defun reftex-setup-capf ()
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-reftex-labels))
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-reftex-citations)))
  :hook
  (LaTeX-mode . reftex-setup-capf))

(use-package company-auctex
  :after tex
  :init
  (defun auctex-setup-capf ()
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-auctex-labels))
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-auctex-bibs))
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-auctex-macros))
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-auctex-symbols))
    (add-to-list 'completion-at-point-functions (cape-company-to-capf #'company-auctex-environments)))
  :hook
  (LaTeX-mode . auctex-setup-capf))

(use-package pdf-tools
  :init
  (pdf-tools-install)
  (setq pdf-view-resize-factor 1.05)) ;; decrease resizing factor for better control

(use-package citar
  :after tex
  :custom
  (citar-bibliography '("~/all.bib")))

(with-temp-buffer
  (activate-input-method "TeX") ;; the input method has to be triggered for `quail-package-alist' to be non-nil
  (let ((quail-current-package (assoc "TeX" quail-package-alist)))
    (quail-define-rules ((append . t))
                        ("^\\alpha" ?ᵅ)
                        ("\\NN" ?ℕ)
                        ("\\ZZ" ?ℤ)
                        ("\\QQ" ?ℚ)
                        ("\\RR" ?ℝ)
                        ("\\CC" ?ℂ))))

(setq-default c-default-style "linux"
              c-basic-offset 2)

(setq auto-mode-alist (cons '("\\.sing\\'" . c++-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.lib\\'" .  c++-mode) auto-mode-alist))

(use-package julia-mode
  :mode "\\.jl\\'") ;; defer loading until and auto-activate when .jl files are opened

(use-package eglot-jl
  :after julia-mode            ;; defer loading until julia-mode is started
  :hook
  (julia-mode . eglot-ensure)  ;; auto-activate when julia-mode is started
  (julia-mode . eglot-jl-init)
  :init
  (setq eglot-connect-timeout nil)
  :config
  (setq eldoc-echo-area-use-multiline-p nil))

(use-package vterm
  :after julia-mode) ;; defer loading until julia-mode is started

(use-package julia-repl
  :after julia-mode                    ;; defer loading until julia-mode is started
  :hook (julia-mode . julia-repl-mode) ;; auto-activate when julia-mode is started
  :init
  (setq exec-path (append exec-path '("/home/ren/.juliaup/bin")))
  (add-to-list 'load-path "/home/ren/.juliaup/bin/julia")
  :config
  (julia-repl-set-terminal-backend 'vterm)) ;; use vterm (recommended)

(use-package copilot
  :straight (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
  :hook (julia-mode . copilot-mode)
  :config
  (setq copilot--base-dir "/home/ren/.emacs.d/straight/repos/copilot.el/")
  (define-key copilot-completion-map (kbd "C-<tab>") 'copilot-accept-completion)
  (setq copilot-indent-offset-warning-disable t)) ;; disables a warning that always arises in tex-mode

(straight-use-package 'gptel)

(setq safe-local-variable-values
      '((eval add-hook 'after-save-hook
              (lambda nil
                (if
                    (y-or-n-p "Tangle?")
                    (org-babel-tangle)))
              nil t)
        (eval add-hook 'after-save-hook
              (lambda nil
                (if
                    (y-or-n-p "Reload?")
                    (load-file user-init-file)))
              nil t)))