Emacs Config

;; -*- lexical-binding: t; -*-

(setq org-babel-default-header-args:emacs-lisp '((:lexical . "yes")))

#+begin_src elisp
(lambda ())
#+end_src

;; 100MB
(setq gc-cons-threshold (* 1024 1024 100))

;; (setq gc-cons-percentage 0.5)

(setq custom-file (locate-user-emacs-file "custom.el"))
;; create custom.el if it does not exists.
(unless (file-exists-p custom-file)
  (write-region "" nil custom-file))
(load custom-file)

(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
(package-initialize)

;; Ensure for all packages
(require 'use-package-ensure)
(setq use-package-always-ensure t)

;; See https://github.com/slotThe/vc-use-package
;; TODO: remove when vc-use-package is merged.
(when (and (not (package-installed-p 'vc-use-package))
           (fboundp 'package-vc-install))
  (package-vc-install "https://github.com/slotThe/vc-use-package"))

(setq native-comp-async-report-warnings-errors nil)

;; Note: the value ("built-in") could actually be any string that does
;; not mach an package archive in `package-archives'.
(setq package-pinned-packages '((org . "built-in")))

;; Save backup files to a dedicated directory.
(setq backup-directory-alist `(("." . ,(expand-file-name "backups" user-emacs-directory))))

;; Use copying to create backup files.
;;
;; The default is nil, which means Emacs moves file to backup and then copy it
;; back. First seen on https://idiomdrottning.org/bad-emacs-defaults.
(setq backup-by-copying t)

;; Make numeric backup versions unconditionally.
(setq version-control t)

;; No not delete backup files.
(setq delete-old-versions -1)

;; Back up files even covered by version control.
(setq vc-make-backup-files t)

;; Don't forget to handle minibuffer with "minibuffer-keyboard-quit".
(keymap-global-set "<escape>" #'keyboard-quit)

;; Avoid entering the ~repeat-complex-cammand~ when quiting everything with ~C-x~.
(keymap-global-unset "C-x <escape> <escape>") ; repeat-complex-command

;; Disabe some Emacs's default keybindings.
(dolist (key '("C-v"    ; scroll-up-command    (Chrome OS: Launcher + <up>)
               "M-v"    ; scroll-down-command  (Chrome OS: Launcher + <down>)
               "C-n"    ; next-line            (Chrome OS: <down>)
               "C-p"    ; previous-line        (Chrome OS: <up>)
               "C-f"    ; next-char            (Chrome OS: <right>)
               "C-b"    ; previous-char        (Chrome OS: <left>)
               "C-s"    ; isearch-forward
               "C-t"    ; switch-char
               "C-l"    ; recenter
               "C-j"    ; electric-newline-and-maybe-indent
               "M-l"    ; downcase-word
               "M-u"    ; upcase-wrod
               "C-z"))  ; suspend-frame
  (keymap-global-unset key))

;; Disable the "numeric argument". When used, I use the =C-u= prefix.
(dolist (prefix '("M-" "C-M-"))
  (keymap-global-unset (concat prefix "-"))
  (dotimes (i 10)
    (keymap-global-unset (concat prefix (number-to-string i)))))

;; Disable the default binding for `compose-mail'.
(keymap-global-unset "C-x m")

(defun my/edit-mode ()
  ;; (hl-line-mode +1)
  (local-set-key (kbd "C-S-s") 'write-file)
  (setq cursor-type 'bar)
  (setq show-trailing-whitespace t))

(defun my/text-mode ()
  (my/edit-mode)
  (visual-line-mode +1)           ; enable "word-wrap"
  (goto-address-mode +1)
  (flyspell-mode))

(defun my/prog-mode ()
  (my/edit-mode)
  (setq truncate-lines t)         ; give ech line of text just one screen line
  (display-line-numbers-mode +1)
  (show-paren-mode +1)
  (goto-address-prog-mode +1)
  (flyspell-prog-mode)
  (hl-line-mode +1)
  (display-fill-column-indicator-mode +1))

(add-hook 'text-mode-hook #'my/text-mode)
(add-hook 'prog-mode-hook #'my/prog-mode)
(add-hook 'conf-mode-hook #'my/prog-mode)

;; Removes the overlay properties which flyspell uses on incorrect words for mouse operations.
;; https://emacs.stackexchange.com/a/55708
(defun make-flyspell-overlay-return-mouse-stuff (overlay)
  (overlay-put overlay 'help-echo nil)
  (overlay-put overlay 'keymap nil)
  (overlay-put overlay 'mouse-face nil))
(advice-add 'make-flyspell-overlay :filter-return #'make-flyspell-overlay-return-mouse-stuff)

;; Remove trailing whitespace except current line.
;; https://stackoverflow.com/a/35781486/1747877
(defun my/delete-trailing-whitespace-except-current-line ()
  "Delete trailing whitespace in the whole buffer, except on the current line.
  The current line exception is because we do want to remove any whitespace
  on the current line on saving the file while we are in-between typing something.

  Do not do anything if `do-not-delete-trailing-whitespace' is non-nil."
  (interactive)
  (when (not (bound-and-true-p do-not-delete-trailing-whitespace))
    (delete-trailing-whitespace (point-min) (line-beginning-position))
    (delete-trailing-whitespace (line-end-position) (point-max))))

(defvar my/save-buffer-with-thread t
  "If non-nil, execute save-buffer with thread so it does not block the UI")

(defun my/save-buffer-advice (orig-fun &rest args)
  (unless (or (buffer-file-name)                       ; regular buffer
              (buffer-file-name (buffer-base-buffer))) ; indirect buffer
    (user-error "Use 'M-x write-file' to save this buffer."))

  (my/delete-trailing-whitespace-except-current-line)

  (if (and my/save-buffer-with-thread
           (not (file-remote-p default-directory))
           ;; Editing with a thread can prevent a buffer from being killed.
           ;; Disable threading on `with-editor-mode' because its
           ;; `with-editor-finish' need to kill the buffer.
           (not (bound-and-true-p with-editor-mode)))
      (make-thread
       (condition-case err
           (apply orig-fun args)
         (error
          (message "Error from my/save-buffer-advice %S" err)
          nil))
       "my/save-buffer-advice")
    (apply orig-fun args)))

(advice-add 'save-buffer :around #'my/save-buffer-advice)

;; auto-save file name conversion.
(setq auto-save-file-name-transforms `((".*" ,(expand-file-name "auto-save-list" user-emacs-directory) t)))

;; Auto save buffer if idled for 2 seconds.
(setq auto-save-timeout 2)
(auto-save-visited-mode 1)

;; Watch and reload the file changed on the disk.
(setq auto-revert-remote-files t)
(global-auto-revert-mode 1)

;; Do not generate any messages.
(setq auto-revert-verbose nil)

;; Do not create lock files (prefix ".#").
(setq create-lockfiles nil)

;; Use a timer instead of file notification.
;;
;; (setq auto-revert-use-notify nil
;;       auto-revert-interval 2)

(defun my/revert-all-buffers ()
  "Refreshes all open buffers from their respective files"
  (interactive)
  (let* ((list (buffer-list))
         (buffer (car list)))
    (while buffer
      (when (and (buffer-file-name buffer)
                 (not (buffer-modified-p buffer)))
        (set-buffer buffer)
        (revert-buffer t t t))
      (setq list (cdr list))
      (setq buffer (car list))))
  (message "Refreshed open files"))

;; Delete the selected text first before editing.
(delete-selection-mode +1)

;; Mouse middle-click yanks where the point is, not where the mouse is.
(setq mouse-yank-at-point t)

;; Scroll just enough text to bring point into view and never centers point.
(setq scroll-conservatively 101)

;; Note: pixel-scroll-precision-mode can break minibuffer scrolling with <prior> and <next>
;; Hence, I am not enabling it.
;;
;; (defun my/pxiel-scroll-enable ()
;;   (when (fboundp 'pixel-scroll-precision-mode)
;;     (pixel-scroll-precision-mode 1)))
;; (defun my/pixel-scroll-disable ()
;;   (when (fboundp 'pixel-scroll-precision-mode)
;;     (pixel-scroll-precision-mode -1)))
;; (add-hook 'minibuffer-setup-hook #'my/pixel-scroll-disable)
;; (add-hook 'minibuffer-exit-hook #'my/pixel-scroll-enable)

;; move line up
(defun my/move-line-up ()
  (interactive)
  (transpose-lines 1)
  (previous-line 2))

;; move line down
(defun my/move-line-down ()
  (interactive)
  (next-line 1)
  (transpose-lines 1)
  (previous-line 1))

(keymap-global-set "M-S-<up>" #'my/move-line-up)
(keymap-global-set "M-S-<down>" #'my/move-line-down)

(setq sentence-end-double-space nil)

(setq-default indent-tabs-mode nil)

;; In case tab is used for indentation, use 2 as the width.
(setq-default tab-width 2)

;; rename-visited-file is introduced in Emacs 29.
(unless (fboundp 'rename-visited-file)
  (defun rename-visited-file ()
    "Renames the current buffer and the file it is visiting."
    (interactive)
    (let ((name (buffer-name))
          (filename (buffer-file-name)))
      (if (not (and filename (file-exists-p filename)))
          (error "Buffer '%s' is not visiting a file!" name)
        (let ((new-name (read-file-name "New name: " filename)))
          (if (get-buffer new-name)
              (error "A buffer named '%s' already exists!" new-name)
            (rename-file filename new-name 1)
            (rename-buffer new-name)
            (set-visited-file-name new-name)
            (set-buffer-modified-p nil)
            (message "File '%s' successfully renamed to '%s'"
                     name (file-name-nondirectory new-name))))))))

(keymap-global-set "C-x R" #'rename-visited-file)

(defun my/delete-file-and-buffer ()
  "Kills the current buffer and deletes the file it is visiting."
  (interactive)
  (if-let ((filename (buffer-file-name)))
      (when (y-or-n-p (concat "Do you really want to delete file " filename " ?"))
        (delete-file filename)
        (message "Deleted file %s." filename)
        (kill-buffer))
    (message "Not a file visiting buffer!")))

(keymap-global-set "C-x K" #'my/delete-file-and-buffer)

(defun with-case-fold-search (orig-fun &rest args)
  (let ((case-fold-search nil))
    (apply orig-fun args)))

(advice-add 'replace-string :around #'with-case-fold-search)

(use-package wgrep)

;; Use year/month/day
(setq calendar-date-style 'iso)

(xterm-mouse-mode +1)

;; Remember and restore the last cursor location of opened files
(save-place-mode 1)

;; Remeber recent files.
(setq recentf-max-saved-items 100)
(recentf-mode +1)

;; Don't pop up UI dialogs when prompting
(setq use-dialog-box nil)

;; Disable the alarm bell (https://www.emacswiki.org/emacs/AlarmBell).
(setq ring-bell-function 'ignore)

;; Use shorter "y" or "n" to confirm killing emacs.
(setq confirm-kill-emacs 'y-or-n-p)

(defun my/set-fonts (default-font-name
                     default-font-height
                     cjk-font-name
                     cjk-font-scale
                     emoji-font-name
                     emoji-font-scale)
  "Helper function to set the default, CJK and Emoji fonts."
  ;; Set the default font
  (when (member default-font-name (font-family-list))
    (set-face-attribute 'default nil
                        :family default-font-name
                        :height default-font-height)
    (set-frame-font default-font-name nil t))

  ;; Set the CJK font in the default fontset.
  (when (member cjk-font-name (font-family-list))
    (dolist (script (list 'han 'kana 'cjk-misc))
      (set-fontset-font t script cjk-font-name)))

  ;; Set the Emoji font in the default fontset.
  (when (member emoji-font-name (font-family-list))
    (set-fontset-font t 'emoji emoji-font-name))

  ;; Rescale the CJK and emoji fonts.
  (setq face-font-rescale-alist
        `((,(format ".*%s.*" cjk-font-name) . ,cjk-font-scale)
          (,(format ".*%s.*" emoji-font-name) . ,emoji-font-scale))))

;; Different computers might need different scaling factors with the
;; same fonts.
(cond
 ;; MacOS, HiDPI
 ((eq system-type 'darwin)
  (my/set-fonts
   "Menlo" 140
   "Hiragino Sans CNS" 1.2
   "Apple Color Emoji" 0.9))
 ;; Default Linux
 (t
  (my/set-fonts
   ;; "Source Code Pro" 90
   "Hack" 90
   "WenQuanYi Micro Hei" 1.20
   "Noto Color Emoji" 0.95)))

(defun my/rescale-height (ratio)
  (let* ((base-height (face-attribute 'default :height)))
    (round (* ratio base-height))))

(defun my/adjust-face-for-modes ()
  "Adjust the face based on the major mode."
  (pcase major-mode
    ('elfeed-show-mode (buffer-face-set :height (my/rescale-height 1.25)))
    ('nov-mode (buffer-face-set :height (my/rescale-height 1.25)))
    ('Info-mode (buffer-face-set :height (my/rescale-height 1.25)))))

(add-hook 'after-change-major-mode-hook #'my/adjust-face-for-modes)

(use-package modus-themes
  :init
  (setq modus-themes-to-toggle
        ;; (light, dark)
        '(modus-operandi-tinted modus-vivendi-tinted))

  (setq modus-themes-headings
        '((agenda-date . (1.2))))

  (setq modus-themes-common-palette-overrides
        '(;; Heading
          (fg-heading-1 blue)
          (fg-heading-2 cyan)
          (fg-heading-3 magenta)
          (fg-heading-4 blue)

          ;; Org Block
          (bg-prose-block-contents bg-blue-nuanced)
          (bg-prose-block-delimiter bg-lavender)
          (fg-prose-block-delimiter fg-main)

          ;; Tab Bar / Tab Line
          (bg-tab-bar bg-main)
          (bg-tab-current bg-active)
          (bg-tab-other bg-dim)))

  (defun my/modus-themes-custom-faces (&rest _)
    (modus-themes-with-colors
      (custom-set-faces
       ;; Add "padding" to the header line
       `(header-line ((,c
                       :underline (:style line :position t :color ,border)
                       :box (:line-width 2 :color ,bg-dim))))

       ;; Active Tab Line
       `(tab-line ((,c
                    :underline (:style line :position t :color ,border)
                    :box (:line-width 10 :color ,bg-dim))))

       ;; Inactive Tab Line
       `(tab-line-tab ((,c
                        :underline (:style line :position t :color ,border)
                        :box (:line-width 10 :color ,bg-dim))))

       `(tab-line-tab-inactive ((,c
                                 :underline (:style line :position t :color ,border)
                                 :box (:line-width 10 :color ,bg-dim))))

       )))
  (add-hook 'modus-themes-after-load-theme-hook #'my/modus-themes-custom-faces)

  (defun my/toggle-theme ()
    (interactive)
    (if (eq system-type 'darwin)
        (shell-command "open -a /Users/whhone/Library/Mobile\\ Documents/com~apple~Automator/Documents/Toggle\\ Dark\\ Theme.app")
      (modus-themes-toggle)))

  (defun my/apply-theme (appearance)
    "Load theme, taking current system APPEARANCE into consideration."
    (pcase appearance
      ('light (modus-themes-select (car modus-themes-to-toggle)))
      ('dark (modus-themes-select (car (cdr modus-themes-to-toggle))))))

  (if (boundp 'ns-system-appearance)
      (add-hook 'ns-system-appearance-change-functions #'my/apply-theme)
    ;; if 8pm ~ 6am, use 'dark them.
    (add-hook 'after-init-hook
              (lambda()
                (my/apply-theme
                 (let ((hour (string-to-number (format-time-string "%H" (current-time)))))
                   (if (or (>= hour 20) (< hour 6)) 'dark 'light))))))

  :bind
  ("<f5>" . my/toggle-theme)
  ("<f6>" . my/toggle-theme))

(tooltip-mode 1)

(use-package breadcrumb
  :config
  (setq breadcrumb-imenu-max-length 1.0)
  (setq breadcrumb-project-max-length 1.0)

  ;; Make Org heading style the same.
  ;; https://github.com/joaotavora/breadcrumb/issues/35
  (defun breadcrumb-org-crumbs ()
    "Get the chain from the top level heading down to current heading."
    (unless (org-before-first-heading-p)
      (org-format-outline-path (org-get-outline-path t)
                               (1- (frame-width)) ; width
                               nil                ; prefix
                               " > ")))           ; separator

  (defun breadcrumb--header-line ()
    "Helper for `breadcrumb-headerline-mode'."
    (let* ((imenu-crumbs (if (eq major-mode 'org-mode)
                             'breadcrumb-org-crumbs
                           'breadcrumb-imenu-crumbs))
           (x (cl-remove-if
               #'seq-empty-p (mapcar #'funcall
                                     `(breadcrumb-project-crumbs ,imenu-crumbs)))))
      (mapconcat #'identity x (propertize " : " 'face 'breadcrumb-face))))

  (breadcrumb-mode))

[Settings]
gtk-application-prefer-dark-theme=1
gtk-icon-theme-name = Adwaita
gtk-theme-name = Adwaita
gtk-key-theme-name = Emacs

;; Turn off mouse interface early in startup to avoid momentary display.
(menu-bar-mode -1)

;; On Emacs without X, tool-bar-mode and scroll-bar-mode are not defined.
(when (fboundp 'tool-bar-mode)
  (tool-bar-mode -1))

(when (fboundp 'scroll-bar-mode)
  (scroll-bar-mode -1))

;; Show column number in the mode line.
(column-number-mode)

(setq inhibit-startup-screen t)
(setq initial-scratch-message ";; scratch buffer\n\n")

(winner-mode +1)

(keymap-global-set "M-o" #'other-window)

(use-package windmove
  :bind
  ("C-M-<up>" . 'windmove-up)
  ("C-M-<down>" . 'windmove-down)
  ("C-M-<left>" . 'windmove-left)
  ("C-M-<right>" . 'windmove-right))

(use-package ace-window
  :disabled
  :bind
  ("M-o" . 'ace-window)
  :custom
  (aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l))
  (aw-scope 'frame))

(defun my/toggle-current-window-dedication ()
  (interactive)
  (let* ((window (selected-window))
         (dedicated (window-dedicated-p window)))
    (set-window-dedicated-p window (not dedicated))
    (message "Window %sdedicated to %s"
             (if dedicated "no longer " "")
             (buffer-name))))
(keymap-global-set "<f10>" #'my/toggle-current-window-dedication)

;; starting Emacs from a directory where you have a saved desktop configuration
;; will restore that configuration.
(setq desktop-path `(,user-emacs-directory))

;; do not load desktop if it is being used.
(setq desktop-load-locked-desktop nil)

;; Set how much buffer to restore immediately. Remaining buffers are restore
;; lazily when Emacs is idle.
;; (setq desktop-restore-eager 0)

;; Disables because desktop-save-mode
;; - keeps too many buffers in memory
;; - slows down start up graduately
;; (desktop-save-mode 1)

(require 'tab-bar)

(setq tab-bar-close-button-show nil)
(setq tab-bar-new-button-show nil)

;; hide the tab bar when only one tab. Looks better especially when editting a file with emacsclient.
(setq tab-bar-show 1)
;; Show the absolute number of the tab
(setq tab-bar-tab-hints t)
;; Switch to tab by C-?
(setq tab-bar-select-tab-modifiers '(control))

(keymap-global-set "C-<tab>" #'tab-next)
(tab-bar-rename-tab "org" 1)
(tab-bar-select-tab 1)

(tab-bar-mode +1)

(defun my/split-window-below ()
  (interactive)
  (split-window-below)
  (other-window 1))

(defun my/split-window-right ()
  (interactive)
  (split-window-right)
  (other-window 1))

(keymap-global-set "C-x 2" #'my/split-window-below)
(keymap-global-set "C-x 3" #'my/split-window-right)

;; The commented code using advice can affect function that handle
;; "other-window" by itself like =org-todo=.
; (defun my/split-window-advice (&rest args) (other-window 1))
; (advice-add 'split-window-below :after #'my/split-window-advice)
; (advice-add 'split-window-right :after #'my/split-window-advice)

(keymap-global-set "C-x -" #'my/split-window-below)
(keymap-global-set "C-x |" #'my/split-window-right)

;; When nil, `split-window-sensibly' is not allowed to split window vertically.
;; e.g., when going to the heading from org-agenda.
(setq split-height-threshold nil)

;; Update the `split-width-threshold' so that it splits at most two
;; windows in a frame horizontally. It has to be a value
;; - <= (`frame-width' * 1.00) so 1 window will split
;; - <= (`frame-width' * 0.67) so 1 window will split with side window
;; - >  (`frame-width' * 0.50) so 2 windows won't split.
(defun my/update-split-width-threshold ()
  (setq split-width-threshold (round (* (frame-width) 0.55))))

;; Update the `split-width-threshold' whenever the window configuration is
;; changed.
(add-hook 'window-configuration-change-hook #'my/update-split-width-threshold)

(setq my/side-window-alist
      `((0 . ,(rx (or "*compilation*"
                      "*eshell*"
                      "*Help*"
                      "*llm*"
                      "*shell*"
                      "*xref*"
                      "*Messages*"
                      "magit: "
                      "COMMIT_EDITMSG"
                      "fig: "
                      "*eldoc*"
                      "*Google Translate*")))
        ;; (1 . ,(rx (or "*vterm*")))
        ))

(defun my/update-display-buffer-alist ()
  (interactive)
  (setq display-buffer-alist nil)
  (dolist (config my/side-window-alist)
    (let* ((config-slot (car config))
           (config-buffer-names (cdr config))
           ;; 1/3 in large screen. 1/2 in small screen.
           (config-width (if (> (frame-width) 240) 0.333 0.4)))
      (add-to-list 'display-buffer-alist
                   `(,config-buffer-names
                     (display-buffer-in-side-window)
                     (side . right)
                     (slot . ,config-slot)
                     (dedicated . t)
                     (window-width . ,config-width)
                     (window-parameters
                      .
                      ;; disable because it makes me easier to switch window
                      ((no-other-window . nil)
                       (no-delete-other-windows . t)))))))

    ;; Place vterm at the bottom side window.
    (add-to-list 'display-buffer-alist
                 `(,(rx "*vterm*")
                   (display-buffer-in-side-window)
                   (side . bottom)
                   (slot . 0)
                   (dedicated . t)
                   ;; (window-width . ,config-width)
                   (window-parameters
                    .
                    ;; disable because it makes me easier to switch window
                    ((no-other-window . nil)
                     (no-delete-other-windows . t))))))

;; Update the `split-width-threshold' whenever the window configuration is
;; changed.
(add-hook 'window-configuration-change-hook #'my/update-display-buffer-alist)

(keymap-global-set "M-`" #'window-toggle-side-windows)
;; for mac os
(keymap-global-set "M-0" #'window-toggle-side-windows)

(defun my/has-side-windows ()
  "Whether the current frame has side windows showing."
  (not (frame-root-window-p (window-main-window))))

(defun my/get-window-side ()
  "Return the side of the current window."
  (window-parameter (frame-selected-window) 'window-side))

;; Sets default-directory to org-directory so that =M-x magit= from the agenda
;; view does not ask me for a dir.
(defun my/org-agenda-advice (orig-fun &rest args)
  (let ((default-directory org-directory))
    ;; If on a side window, switch away.
    ;; Otherwise, `org-agenda' throws error "cannot make side window the only window"
    (when (my/get-window-side) (other-window 1))
    (apply orig-fun args)))
(advice-add 'org-agenda :around #'my/org-agenda-advice)

;; [experimental] if possible, only enable in side windows.
;; (global-tab-line-mode)

(use-package vertico
  :init
  (vertico-mode)
  (setq vertico-count 25)
  :bind
  (:map vertico-map
        ([escape] . minibuffer-keyboard-quit)
        ("<prior>" . vertico-scroll-down)
        ("<next>" . vertico-scroll-up)))

;; Persist history over Emacs restarts. Vertico sorts by history position.
(use-package savehist
  :init
  (savehist-mode))

;; A few more useful configurations...
;; Add prompt indicator to `completing-read-multiple'.
;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
(defun crm-indicator (args)
  (cons (format "[CRM%s] %s"
                (replace-regexp-in-string
                 "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
                 crm-separator)
                (car args))
        (cdr args)))
(advice-add #'completing-read-multiple :filter-args #'crm-indicator)

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

;; Emacs 28: Hide commands in M-x which do not work in the current mode.
;; Vertico commands are hidden in normal buffers.
(setq read-extended-command-predicate
      #'command-completion-default-include-p)

;; Enable recursive minibuffers
(setq enable-recursive-minibuffers t)

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

(use-package consult
  :bind
  ("C-f" . consult-line)
  ("C-j" . consult-imenu)
  ("C-o" . my/consult-org)
  ("C-r" . consult-recent-file)
  ("C-x r r" . consult-bookmark)

  ("C-x b" . consult-buffer)                ;; orig. switch-to-buffer
  ("C-x p b" . consult-project-buffer)      ;; orig. project-switch-to-buffer
  ("M-y" . consult-yank-pop)                ;; orig. yank-pop
  ("M-g g" . consult-goto-line)             ;; orig. goto-line
  :init
  (with-eval-after-load "org"
    (defun my/jump-org-heading-advice (&rest args)
      "Show entry and children of the current org heading."
      ;; Note: 'org-cycle-*' and 'org-fold-*' below are not not available in Emacs 28 or below.
      ;; Alternatives
      ;; - trigger org-cycle-overview when requested (e.g., only in my/org-random-heading)
      ;; - use narrowing
      (when (fboundp 'org-cycle-overview)
        (org-cycle-overview)
        (org-fold-show-entry)
        (org-fold-show-children))
      (org-reveal))
    (advice-add 'consult-org-heading :after #'my/jump-org-heading-advice)
    (define-key org-mode-map (kbd "C-j") #'consult-org-heading))

  (with-eval-after-load "org-agenda"
    (define-key org-agenda-mode-map (kbd "C-j") #'consult-org-agenda)))

;; Full text search the whole org directory
(defun my/consult-org (arg)
  "Consult the org agenda headings. If prefix is provided, performs full text search."
  (interactive "P")
  (require 'consult)
  (if arg
      ;; "--no-ignore-vcs" : inbox.org can also be search.
      ;; "-t org" :  only search for org file.
      (let ((consult-ripgrep-args (concat consult-ripgrep-args " --no-ignore-vcs" " -t org")))
        (consult-ripgrep org-directory ""))
    (consult-org-agenda "LEVEL<=3")))

(use-package marginalia
  :init
  (setq marginalia-align 'center)
  (marginalia-mode))

(use-package embark
  :bind
  (("C->" . embark-act)         ;; pick some comfortable binding
   ("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)

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

;; Consult users will also want the embark-consult package.
(use-package embark-consult
  :hook
  (embark-collect-mode . consult-preview-at-point-mode))

(use-package which-key
  :custom
  ;; (which-key-idle-delay 10000 "Set idle delay to infinite so it never trigger automatically")
  ;; (which-key-show-early-on-C-h t "Allow C-h to trigger which-key before it is done automatically.")
  ;; (which-key-idle-secondary-delay 0.05)
  (which-key-mode +1 "Non-nil if which-Key mode is enabled"))

(use-package hydra
  :commands defhydra
  :init
  (defhydra hydra-consult-menu (:hint nil
                                      :foreign-keys warn
                                      :exit t
                                      :pre (setq which-key-inhibit t)
                                      :post (setq which-key-inhibit nil))
    "===== Consult Menu (F12) =====\n"
    ("f" (my/consult-org-agenda) "Agenda")
    ("r" (consult-recent-file) "Recentf")
    ("q" nil "quit menu" :color blue))
  (keymap-global-set "<f8>" #'hydra-consult-menu/body))

(use-package hydra
  :commands defhydra
  :init
  (defhydra hydra-file-menu (:hint nil
                                   :foreign-keys warn
                                   :exit t
                                   :pre (setq which-key-inhibit t)
                                   :post (setq which-key-inhibit nil))
    ("er" (load-file user-init-file))
    ("ed" (let ((vc-follow-symlinks t)) (find-file (locate-user-emacs-file "dotemacs.org"))) "dotemacs.org")
    ("ep" (let ((vc-follow-symlinks t)) (find-file (locate-user-emacs-file "private.org"))) "private.org")
    ("eg" (let ((vc-follow-symlinks t)) (find-file (locate-user-emacs-file "google.org"))) "google.org")
    ("ef" (let ((vc-follow-symlinks t)) (find-file (locate-user-emacs-file "elfeed.org"))) "elfeed.org")

    ("i" (find-file (my/org-inbox-file)) "inbox.org")
    ("p" (find-file (my/org-tasks-file)) "tasks.org")
    ("r" (find-file (my/org-references-file)) "references.org")
    ("d" (find-file (my/org-diary-file)) "diary.org")
    ("b" (find-file (my/org-blog-file)) "blog.org")

    ("w" (find-file (my/org-work-file) "work.org"))
    ("D" (find-file "~/org/work/diary.org") "work/diary.org")

    ("sc" (my/sudo-find-file "/etc/caddy/conf.d/whhone.com.Caddyfile") "sudo:Caddyfile")
    ("ss" (my/sudo-find-file "/etc/samba/smb.conf") "sudo:smb.conf")

    ("q" nil "quit menu" :color blue))

  (keymap-global-set "C-c e" #'hydra-file-menu/body))

(defun my/current-date ()
  (concat "[" (shell-command-to-string "echo -n $(date '+%Y-%m-%d %a')") "]"))

;; NOTE: Consider using "org-time-stamp-inactive" if there is a way to
;; avoid the date selection prompt.
(defun my/insert-current-date ()
  (interactive)
  (insert (my/current-date)))

(keymap-global-set "C-c d" #'my/insert-current-date)

(use-package hydra
  :commands defhydra
  :init
  (defhydra my/hydra-snippets (:hint nil
                                     :foreign-keys warn
                                     :exit t)
    "Snippets"
    ("d" (my/insert-current-date) "Current Date (yyyy-mm-dd Aaa)")
    ("q" nil "Quit Menu"))

  (keymap-global-set "C-c s" #'my/hydra-snippets/body))

(require 'org)

;; Adding a "/" so that =find-file= finds the files under =~/org/=.
(setq org-directory "~/org/")
(defun my/expand-org-file-name (filename)
  (expand-file-name filename org-directory))

(defun my/org-inbox-file () (my/expand-org-file-name "inbox.org"))
(defun my/org-tasks-file () (my/expand-org-file-name "tasks.org"))
(defun my/org-references-file () (my/expand-org-file-name "references.org"))
(defun my/org-diary-file () (my/expand-org-file-name "diary.org"))
(defun my/org-blog-file () (my/expand-org-file-name "blog/ox/content.org"))
(defun my/org-work-file () (my/expand-org-file-name "work.org"))
(defun my/org-drill-file () (my/expand-org-file-name "drill.org"))
(defun my/org-calendar-directory () (my/expand-org-file-name ".calendar/"))
(defun my/org-attachment-directory () (my/expand-org-file-name ".attachment/"))
(defun my/org-emacs-config-file () (expand-file-name "dotemacs.org" user-emacs-directory))

(keymap-global-set "C-c c" #'org-capture)

;; The default file for capturing.
(setq org-default-notes-file (my/org-inbox-file))

;; Org Capture Templates
;;
;; See https://orgmode.org/manual/Template-elements.html#index-org_002ddefault_002dnotes_002dfile-1
(setq org-capture-templates nil)
(add-to-list
 'org-capture-templates
 `("i" "Inbox" entry (file+headline ,(my/org-tasks-file) "Inbox")
   "* %?\n%i\n%a"))

(add-to-list
 'org-capture-templates
 `("I" "Inbox (Work)" entry (file+headline ,(my/org-work-file) "Inbox")
   "* %?\n%i\n%a"))

(add-to-list
 'org-capture-templates
 `("p" "Project" entry (file+headline ,(my/org-tasks-file) "Projects")
   (file "~/org/.template/project.org")))

(add-to-list
 'org-capture-templates
 `("v" "Vocab" entry (file+headline ,(my/org-drill-file) "Translation")
   "* %? :drill:\n\n** Translation\n\n** Definition\n"))

(use-package org-cliplink)

(require 'org-attach)
(setq org-attach-id-dir (my/org-attachment-directory))
(setq org-attach-use-inheritance t)

;; Use timestamp as ID and attachment folder. See https://helpdeskheadesk.net/2022-03-13/
;; (setq org-id-method 'ts)
;; (setq org-attach-id-to-path-function-list
;;       '(org-attach-id-ts-folder-format
;;         org-attach-id-uuid-folder-format))
;; Shorten the Org timestamp ID
;; (setq org-id-ts-format "%Y%m%dT%H%M%S")

;; Note: WAIT(w) is an experimental state for short-term wait (~10
;; mins ~ few hours) within today so that I can switch to anther task
;; and come back later.
(setq org-todo-keywords '((sequence "TODO(t)" "NEXT(n)" "PROG(p)" "WAIT(w)" "|" "DONE(d)")
                          (sequence "QUESTION(q)" "|")
                          (sequence "|" "CANCELED(c)")))

(keymap-global-set "C-c a" #'org-agenda)

;; https://orgmode.org/worg/org-tutorials/org-custom-agenda-commands.html
;; Note: "tags" search is slow.
(setq org-agenda-custom-commands
      `(("n" "Agenda / PROG / TODO"
         ((agenda)
          (tags "INBOX+LEVEL=2|CATEGORY=\"Inbox\"+LEVEL=1")
          (todo "WAIT")
          (todo "PROG")
          (todo "NEXT")
          (tags "@jing|@casper|@cayden"))
         ((org-agenda-files
                 '(,(my/org-inbox-file)
                   ,(my/org-tasks-file)))))))

;; My agenda files.
(setq org-agenda-files
      (list (my/org-inbox-file)
            (my/org-tasks-file)
            (my/org-references-file)
            (my/org-blog-file)
            (my/org-emacs-config-file)
            ;; (my/org-calendar-directory)
            ))

;; Trying to use the current window as agenda frame.
(setq org-agenda-window-setup 'current-window)

;; Use sticky agenda since I need different agenda views (personal and work) at the same time.
(setq org-agenda-sticky t)

;; Just today
(setq org-agenda-span 'day)

;; Hide all scheduled todo.
(setq org-agenda-todo-ignore-scheduled 'all)

;; Ignores "far" deadline TODO items from TODO list.
(setq org-agenda-todo-ignore-deadlines 'far)

;; Hide all scheduled todo, from tags search view, like tags-todo.
(setq org-agenda-tags-todo-honor-ignore-options t)

;; Hide all done todo in agenda
(setq org-agenda-skip-scheduled-if-done t)

;; Hide task until the scheduled date.
(setq org-agenda-skip-deadline-prewarning-if-scheduled 'pre-scheduled)

;; Make blocked tasks invisible in the agenda.
(setq org-agenda-dim-blocked-tasks 'invisible)

;; Use an indirect buffer after <Tab> (org-agenda-goto) or <Enter> (org-agenda-switch-to).
;;
;; Also see https://emacs.stackexchange.com/a/17822
;; (advice-add 'org-agenda-goto :after
;;             (lambda (&rest args)
;;               (org-tree-to-indirect-buffer)))
;; (advice-add 'org-agenda-switch-to :after
;;             (lambda (&rest args)
;;               (org-tree-to-indirect-buffer)))

;; Narrow to subtree after <Tab> (org-agenda-goto) or <Enter> (org-agenda-switch-to).
;; (advice-add 'org-agenda-goto :after
;;             (lambda (&rest args)
;;               (org-narrow-to-subtree)))
;; (advice-add 'org-agenda-switch-to :after
;;             (lambda (&rest args)
;;               (org-narrow-to-subtree)))

(advice-add 'org-agenda-goto :after #'my/jump-org-heading-advice)
(advice-add 'org-agenda-switch-to :after #'my/jump-org-heading-advice)

(setq org-enforce-todo-dependencies t)

(setq org-log-into-drawer t)
;; (setcdr (assoc 'note org-log-note-headings) "%d")
;; Interstitial Journaling: add note to CLOCK entry after clocking out
;; https://emacs.stackexchange.com/questions/37526/add-note-to-clock-entry-after-clocking-out
(setq org-log-note-clock-out t)

;; 4 priorities to model Eisenhower's matrix.
;; - [#A] means +important +urgent
;; - [#B] means +important -urgent
;; - [#C] means -important +urgent
;; - [#D] means -important -urgent
(setq org-priority-default 68
      org-priority-lowest 68)

;; Include the file name into the path in refile target.
;; Also see https://github.com/minad/vertico?tab=readme-ov-file#org-refile
(setq org-refile-use-outline-path 'file)
(setq org-outline-path-complete-in-steps nil)
(setq org-refile-targets `((nil :maxlevel . 2)))

(defun my/bookmark-jump-org-refile-last-stored (&rest args)
  (bookmark-jump "org-refile-last-stored"))

(advice-add 'org-refile :after #'my/bookmark-jump-org-refile-last-stored)

(defun my/org-random-heading ()
  "Jump to a random org heading in the current org file."
  (interactive)
  (goto-char (point-min))
  (let ((headings '()))
    (while (re-search-forward "^\\*+ " nil t)
      (push (point) headings))
    (when headings
      (goto-char (nth (random (length headings)) headings))
      (my/jump-org-heading-advice))))

(with-eval-after-load "org"
  (define-key org-mode-map (kbd "C-c r") #'my/org-random-heading))

(define-key org-mode-map (kbd "C-x n n") #'org-toggle-narrow-to-subtree)

(defun my/sync-calendar()
  (interactive)
  (message "Synchronizing...")
  (shell-command "~/org/.calendar/fetch.sh")
  (message "Synchronized."))

(org-babel-do-load-languages
 'org-babel-load-languages
 '((emacs-lisp . t) (shell . t) (python . t) (gnuplot . t) (ditaa . t)))

(setq org-edit-src-content-indentation 0)

;; Silent result by default. Append to override the default value.
(add-to-list 'org-babel-default-header-args:emacs-lisp '(:results . "silent") t)
;; (add-to-list 'org-babel-default-header-args:python '(:results . "replace") t)

;; Use python3.
(setq org-babel-python-command "python3")

(use-package org-auto-tangle
  :defer t
  :config
  (setq org-auto-tangle-default t))

(setq org-insert-heading-respect-content t)

(setq org-clock-mode-line-total 'current)
(setq org-show-notification-timeout 3600)

;; Comment out since I forgot why I added it.
;; (org-clock-auto-clockout-insinuate)

;; Create an indirect buffer for the current clocking task, and focus into it.
(defun my/org-clock-goto ()
  (interactive)
  (org-clock-goto)
  (org-tree-to-indirect-buffer)
  (other-window 1)
  (delete-other-windows))
(keymap-global-set "C-c C-x j" #'my/org-clock-goto)

;; Enable the =org-indent-mode= by default.
(setq org-startup-indented t)

;; Set #+STARTUP: fold by default.
(setq org-startup-folded t)

;; Reduce org-indent-indentation-per-level from 2 to 1.
;;
;; This keeps =org-tags-column= the same for all headings.
;; Avoid inconsistency when eidting outside Emacs, like Beorg.
;; Note that Orgzly has option the customize this variable.
;; (setq org-indent-indentation-per-level 2)

;; Whether to display the inline image at startup.
(setq org-startup-with-inline-images nil)

;; Display the image roughly match the org-tags-column.
;;
;; To customize the width, use "#+ATTR_ORG: :width <new_width>".
(setq org-image-actual-width 600)

;; To enable preview on startup globally
(setq org-startup-with-latex-preview nil)

;; Slightly increase the size of the Latex fragment previews.
(setq org-format-latex-options (plist-put org-format-latex-options :scale 1.2))

;; Put the generated image to an absolute directory.
;;
;; A side effect is that all latex images from this shared directory
;; might be copied during exporting.
;; e.g., ox-hugo (https://github.com/kaushalmodi/ox-hugo/issues/723)
;; (setq org-preview-latex-image-directory
;;       (expand-file-name "preview/ltximg/" user-emacs-directory))

;; 2023-10-13: I prefer using M-x org-toggle-pretty-entities instead.
;; (setq org-pretty-entities t)

(use-package gnuplot)

(use-package org-preview-html)

;; (setq org-element-use-cache nil)

(use-package ox-hugo
  :after ox
  :config
  ;; By default, export to the /content/.
  (setq org-hugo-section "")
  (add-to-list 'org-hugo-external-file-extensions-allowed-for-copying "webm"))

;; Do not export with TOC, e.g., with org-md-export-as-markdown, org-ascii-export-as-ascii
(setq org-export-with-toc nil)

;; (setq org-export-with-section-numbers nil)

(setq org-list-allow-alphabetical t)

;; https://orgmode.org/worg/org-contrib/org-drill.html
(use-package org-drill
  :config
  ;; save buffers after drill sessions without prompt.
  (setq org-drill-save-buffers-after-drill-sessions-p nil)
  ;; reduce from the default 30 to make it to become a habit.
  (setq org-drill-maximum-items-per-session 10))

(dolist (arrow '("left", "right", "up", "down"))
  (define-key org-mode-map (kbd (format "C-c <%s>" arrow)) nil))

(define-key org-mode-map (kbd "C-c ,") #'org-insert-structure-template)

(use-package google-translate
  :init
  (setq google-translate-default-source-language "en")
  (setq google-translate-default-target-language "zh-TW")
  (setq google-translate-output-destination nil)
  :bind
  ("C-c v" . google-translate-at-point))

(add-hook 'help-mode-hook #'visual-line-mode)

(use-package nov
  :init
  (add-to-list 'auto-mode-alist '("\\.epub\\'" . nov-mode))
  :config
  (setq nov-unzip-program (executable-find "bsdtar")
        nov-unzip-args '("-xC" directory "-f" filename)))

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

(setq ispell-personal-dictionary
      (expand-file-name ".personal-dictionary.pws" org-directory))

(require 'auth-source)

(add-to-list 'auth-sources (expand-file-name ".authinfo" user-emacs-directory))
(add-to-list 'auth-sources (expand-file-name ".authinfo.nogit" user-emacs-directory))

(use-package llm
  :init
  (setq llm-warn-on-nonfree nil)
  (require 'llm-openai)
  (setq my/llm-provider-openai
        (make-llm-openai :key (auth-source-pick-first-password :host "api.openai.com")))
  (require 'llm-gemini)

  ;; 0.075 per 1 million tokens
  (setq my/llm-provider-gemini-flash
        (make-llm-gemini :key (auth-source-pick-first-password :host "gemini")
                         :chat-model "gemini-1.5-flash"))

  ;; $1.25 per 1 million tokens (~17 times more expensive)
  (setq my/llm-provider-gemini-pro
        (make-llm-gemini :key (auth-source-pick-first-password :host "gemini")
                         :chat-model "gemini-1.5-pro"))
  (require 'llm-ollama)
  (setq my/llm-provider-ollama-gemma2-2b
        (make-llm-ollama :chat-model "gemma2:2b"))
  (setq my/llm-provider-ollama-gemma2
        (make-llm-ollama :chat-model "gemma2"))
  (setq my/llm-provider-ollama-gemma2-27b
        (make-llm-ollama :chat-model "gemma2:27b"))
  (setq my/llm-provider-ollama-llama-1b
        (make-llm-ollama :chat-model "llama3.2:1b"))

  (setq
   my/llm-providers
   `(("Gemini Flash" . ,my/llm-provider-gemini-flash)
     ("Gemini Pro" . ,my/llm-provider-gemini-pro)
     ("Open AI" . ,my/llm-provider-openai)
     ("Gemma2" . ,my/llm-provider-ollama-gemma2)
     ("Gemma2 2B" . ,my/llm-provider-ollama-gemma2-2b)
     ("Gemma2 27B" . ,my/llm-provider-ollama-gemma2-27b)
     ("lamma 1B" . ,my/llm-provider-ollama-llama-1b)))

  (defun my/consult-llm-switch-provider ()
    "Switch the LLM provider."
    (interactive)
    (require 'consult)
    (let ((selected (consult--read
                     (mapcar #'car my/llm-providers)
                     :prompt "Switch my LLM provider: "
                     :require-match t)))
      (message "Switched LLM provider to '%s'" selected)
      (setq my/llm-provider (cdr (assoc selected my/llm-providers)))))

  (setq my/llm-provider my/llm-provider-ollama-llama-1b))

(defun my/get-region-string ()
  "Returns the string of the current active region."
  (unless (region-active-p)
    (user-error "No region active"))
  (buffer-substring (region-beginning) (region-end)))

(defun my/llm-buffer()
  (get-buffer-create "*llm*"))

(defun my/llm-buffer-update (content)
  "Update the buffer `my/llm-buffer' with the `content'."
  (with-temp-buffer
    (insert content)
    (delete-trailing-whitespace)
    (let ((temp-buffer-name (buffer-name)))
      (with-current-buffer (my/llm-buffer)
        (replace-buffer-contents temp-buffer-name)))))

(defun my/llm-buffer-prompt (provider prompt)
  (let ((prompt-info-heading (llm-chat-prompt-to-text prompt)))
    (display-buffer (my/llm-buffer))

    (with-current-buffer (my/llm-buffer)
      ;; (visual-line-mode +1)
      (markdown-mode))

    (my/llm-buffer-update
     (concat prompt-info-heading "==== THINKING ====\n\n"))

    (llm-chat-streaming
     provider
     prompt
     `(lambda (response)
        (my/llm-buffer-update
         (concat ,prompt-info-heading "==== PARTIAL ====\n\n" response)))
     `(lambda (response)
        (my/llm-buffer-update
         (concat ,prompt-info-heading "==== FULL ====\n\n" response)))
     `(lambda (err msg)
        (my/llm-buffer-update
         (concat ,prompt-info-heading (format "==== ERROR ====\n\n %S %S" err msg) response))))))

(defun my/llm-region-with-header (header)
  (interactive "sHeader: ")
  (when (region-active-p)
    (my/llm-buffer-prompt
     my/llm-provider
     (make-llm-chat-prompt
      :interactions
      (list
       ;; Note: adding 'system break Gemini.
       ;; (make-llm-chat-prompt-interaction
       ;;  :role 'system
       ;;  :content "Be brief. Reply in less than 100 words.")
       (make-llm-chat-prompt-interaction
        :role 'user
        :content (concat header "\n\n" (my/get-region-string))))))))

(defun my/llm-org-heading-with-header (header)
  (interactive "sHeader: ")
  (my/llm-buffer-prompt
   my/llm-provider
   (llm-make-simple-chat-prompt
    (concat header "\n\n" (my/org-breadcrumbs)))))

;; Explaining

(defun my/llm-explain-org-heading ()
  (interactive)
  (my/llm-org-heading-with-header
   "Explain the given topic briefly and provides 3 fun facts to help me remembering and learning it:"))

;; Writing

(defun my/llm-write-org-heading ()
  (interactive)
  (my/llm-org-heading-with-header
   "Write an article for the topic briefly in Markdown:"))

(setq my/llm-headers '())
;; When selected, `my/consult-llm' will ask for the header.
(add-to-list 'my/llm-headers '("*Custom*" . nil))

(add-to-list 'my/llm-headers '("Proofread" . "Proofread the text. Highlight the differences:"))
(add-to-list 'my/llm-headers '("Fix Grammar" . "Fix grammar and explain the mistakes:"))
(add-to-list 'my/llm-headers '("Rewrite Funny" . "Rewrite the text in a funny manner:"))
(add-to-list 'my/llm-headers '("Rewrite Formal" . "Rewrite the text formally and keep it easy to read and understand:"))
(add-to-list 'my/llm-headers '("Rewrite Simple" . "Rewrite the text so that it is easy to read and understand, in complete sentences:"))
(add-to-list 'my/llm-headers '("Translate to English" . "Translate to English:"))
(add-to-list 'my/llm-headers '("Translate to Chinese" . "Translate to Traditional Chinese:"))
(add-to-list 'my/llm-headers '("Critique" . "Critique the content:"))
(add-to-list 'my/llm-headers '("Explain with Fun Facts" . "Explain the content briefly and provides 3 fun facts to help remembering and learning it:"))
(add-to-list 'my/llm-headers '("Bloom's Revised Taxonomy Questions" . "Give me questions of the content at Bloom's revised taxonomy levels."))
(add-to-list 'my/llm-headers '("Summerize" . "Summerize the content briefly and list the key highlights:"))
(add-to-list 'my/llm-headers '("Code Explain" . "Please explain the code:"))
(add-to-list 'my/llm-headers '("Code Refactor" . "Please help me refactor the code.
   Please reply with the refactoring explanation in English, refactored code, and diff between two versions.
   Please ignore the comments and strings in the code during the refactoring.
   If the code remains unchanged after refactoring, please say 'No need to refactor'."))

(defun my/consult-llm ()
  "Consult llm.

If there is an active region, then act on that. Otherwise, ask the user for the prompt."
  (interactive)
  (let ((llm--name (llm-name my/llm-provider)))
    (if (not (region-active-p))
        (my/llm-buffer-prompt
         my/llm-provider
         (llm-make-simple-chat-prompt
          (read-string
           (format "Enter prompt for %s: " llm--name))))
      (require 'consult)
      (let* ((selected (consult--read
                        (mapcar #'car my/llm-headers)
                        :prompt (format "Select header for %s: " llm--name)
                        :require-match t))
             (header (or (cdr (assoc selected my/llm-headers))
                         (read-string "Custom header: "))))
        (my/llm-region-with-header header)))))

(keymap-global-set "M-j" #'my/consult-llm)

(use-package gptel
  :config
  (setq
   gptel-model "gemini-1.5-flash"
   gptel-backend (gptel-make-gemini "Gemini"
                   :key (auth-source-pick-first-password :host "gemini")
                   :stream t))
  (setq
   gptel-model "llama3.2:1b"
   gptel-backend (gptel-make-ollama "Ollama"
                   :host "localhost:11434"
                   :stream t
                   :models '("llama3.2:1b"))))

(use-package diff-hl
  :init
  (global-diff-hl-mode)
  :config
  ;; Added in https://github.com/dgutov/diff-hl/pull/207
  (setq diff-hl-update-async t)
  (diff-hl-flydiff-mode +1)

  ;; Automatic diff-hl-margin-mode in terminal.
  ;; See https://github.com/dgutov/diff-hl/issues/155.
  (add-hook 'diff-hl-mode-on-hook
            (lambda ()
              (unless (display-graphic-p)
                (diff-hl-margin-local-mode))))
  :hook
  (magit-pre-refresh . diff-hl-magit-pre-refresh)
  (magit-post-refresh . diff-hl-magit-post-refresh))

(use-package magit
  :init
  (setq magit-define-global-key-bindings 'recommended)

  ;; always visit file in another window.
  (defun my/magit-diff-visit-file-advice (file &optional other-window)
    (magit-diff-visit-file-other-window file))
  (advice-add 'magit-diff-visit-file :override #'my/magit-diff-visit-file-advice)

  ;; this binds `magit-project-status' to `project-prefix-map' when
  ;; project.el is loaded.
  (require 'magit-extras))

;; Use the entire "project-prefix-map" in "project-switch-project".
(setq project-switch-use-entire-map t)

(defun my/project-all-project-files ()
  "Get a list of all files in all known projects."
  (cl-mapcan
   (lambda (project)
     (when (file-exists-p project)
       (mapcar (lambda (file)
                 (expand-file-name file project))
               (project-files (project-current nil project)))))
   (project-known-project-roots)))

(defun my/project-find-file-in-known-projects ()
  "Find a file from all known projects."
  (interactive)
  (let* ((completion-ignore-case read-file-name-completion-ignore-case)
         ;; Note that "project--read-file-cpd-relative" is broken for
         ;; this function since Emacs 29. Instead of using
         ;; "project-read-file-name-function", always use
         ;; "project--read-file-absolute".
         (file (project--read-file-absolute
                "Find file in known projects" (my/project-all-project-files) nil nil
                (thing-at-point 'filename))))
    (if (string= file "")
        (user-error "You didn't specify the file")
      (find-file file))))

(define-key project-prefix-map (kbd "a") #'my/project-find-file-in-known-projects)