Configurations for GNU Emacs

(require 'flymake-proc)

(autoload-if-found '(flycheck-mode) "flycheck" nil t)

(with-eval-after-load 'flycheck
  (flycheck-define-checker textlint
    "A linter for prose."
    :command ("textlint" "--format" "unix" source-inplace)
    :error-patterns
    ((warning line-start (file-name) ":" line ":" column ": "
              (id (one-or-more (not (any " "))))
              (message (one-or-more not-newline)
                       (zero-or-more "\n" (any " ") (one-or-more not-newline)))
              line-end))
    :modes (org-mode))
  (add-to-list 'flycheck-checkers 'textlint))

(autoload-if-found '(flycheck-elsa-setup) "flycheck-elsa" nil t)

(with-eval-after-load 'elisp-mode
  (add-hook 'emacs-lisp-mode-hook #'flycheck-elsa-setup))

(autoload-if-found '(flycheck-projectile-list-errors) "flycheck-projectile" nil t)

(autoload-if-found '(flycheck-cfn-setup) "flycheck-cfn" nil t)

(with-eval-after-load 'cfn-mode
  (add-hook 'cfn-mode-hook #'flycheck-cfn-setup))

(autoload-if-found '(global-corfu-mode) "corfu" nil t)

(add-hook 'after-init-hook #'global-corfu-mode)

(with-eval-after-load 'corfu
  (setopt corfu-auto t)
  (setopt corfu-auto-delay 0.2)
  (setopt corfu-auto-prefix 2)
  (setopt corfu-cycle t)
  (setopt corfu-on-exact-match nil)
  (setopt corfu-quit-no-match 'separator)

  (require 'corfu-popupinfo)
  (require 'corfu-history)
  (corfu-popupinfo-mode 1)
  (corfu-history-mode 1)

  (when (< emacs-major-version 31)
    (require 'corfu-terminal)
    (corfu-terminal-mode 1)))

(with-eval-after-load 'savehist
  (add-to-list 'savehist-additional-variables 'corfu-history))

(with-eval-after-load 'indent
  (setopt tab-always-indent 'complete))

(autoload-if-found '(cape-file
                     cape-dabbrev
                     cape-elisp-block
                     cape-history) "cape" nil t)

(with-eval-after-load 'cape
  (setopt cape-dabbrev-min-length 2))

(add-hook 'completion-at-point-functions #'cape-dabbrev)
(add-hook 'completion-at-point-functions #'cape-file)
(add-hook 'completion-at-point-functions #'cape-elisp-block)
(add-hook 'completion-at-point-functions #'cape-history)

(autoload-if-found '(prescient-persist-mode) "prescient" nil t)

(add-hook 'after-init-hook #'prescient-persist-mode)

(with-eval-after-load 'prescient
  (setopt prescient-aggressive-file-save t))

(autoload-if-found '(kind-icon-margin-formatter) "kind-icon" nil t)

(with-eval-after-load 'corfu
  (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter))

  (autoload-if-found '(global-git-commit-mode) "git-commit" nil t)
  (autoload-if-found '(magit-status magit-blame) "magit")
  (autoload-if-found '(magit-branch) "magit-branch")

  (add-hook 'after-init-hook #'global-git-commit-mode)

  (keymap-global-set "C-x g" #'my/magit-status)
  (keymap-global-set "C-x G" #'magit-blame)

  (defun my/vcs-root (dir)
    "Return (KIND . ROOT) for the repository enclosing DIR, or nil.
The nearest ancestor of DIR holding a .jj or .git entry decides, so a git
checkout nested under a jj repository is git and a colocated checkout, which
has both entries, is jj.  KIND is `jj' or `git'; ROOT is a directory name.
statusline.sh applies the same nearest-.jj/.git rule."
    (when-let* ((root (locate-dominating-file
                       dir
                       (lambda (d)
                         (or (file-exists-p (expand-file-name ".jj" d))
                             (file-exists-p (expand-file-name ".git" d)))))))
      (cons (if (file-exists-p (expand-file-name ".jj" root)) 'jj 'git) root)))

  (defun my/jj-call (root &rest args)
    "Run `jj -R ROOT ARGS'; return (EXIT STDOUT STDERR) with both streams trimmed.
Uses `call-process' with an argument list so no value is reinterpreted as
shell syntax."
    (let ((err-file (make-temp-file "jj-stderr-")))
      (unwind-protect
          (with-temp-buffer
            (let ((exit (apply #'call-process "jj" nil (list t err-file) nil "-R" root args)))
              (list exit
                    (string-trim (buffer-string))
                    (progn (erase-buffer)
                           (insert-file-contents err-file)
                           (string-trim (buffer-string))))))
        (delete-file err-file))))

  (defun my/jj-output (root &rest args)
    "Run `jj -R ROOT ARGS'; return trimmed stdout, or nil on nonzero exit."
    (pcase-let ((`(,exit ,out ,_) (apply #'my/jj-call root args)))
      (and (zerop exit) out)))

  (defun my/jj-output-or-error (root &rest args)
    "Like `my/jj-output', but signal an error carrying jj's stderr on failure."
    (pcase-let ((`(,exit ,out ,err) (apply #'my/jj-call root args)))
      (if (zerop exit)
          out
        (error "jj %s failed (exit %s): %s" (string-join args " ") exit err))))

  (defun my/magit-status ()
    "Open majutsu in a jj repository and magit otherwise."
    (interactive)
    (let ((vcs (my/vcs-root default-directory)))
      (if (eq (car vcs) 'jj)
          (majutsu-log (cdr vcs))
        (let ((default-directory (locate-dominating-file default-directory ".git")))
          (magit-status)))))

  (defun my/update-magit-repository-directories (&optional roots)
    "Populate `magit-repository-directories' from the same ghq-aware root set
that backs `projectile-known-projects' (bare repos contribute only their
worktree children; non-bare repos contribute themselves), each paired with
depth 0 per Magit's (DIRECTORY . DEPTH) format (magit-repository-directories
docstring / magit.vc Repository List manual).  ROOTS, when supplied, is used
directly instead of recomputing via `my/ghq-project-roots'."
    (interactive)
    (setopt magit-repository-directories
            (mapcar (lambda (d) (cons (abbreviate-file-name (file-name-as-directory d)) 0))
                    (or roots (my/ghq-project-roots)))))

  (with-eval-after-load 'magit
    (setopt magit-refresh-status-buffer nil))

  (with-eval-after-load 'magit-status


    (define-key magit-status-mode-map (kbd "C-j") #'magit-visit-thing))

  (with-eval-after-load 'magit-log
    (define-key magit-log-mode-map (kbd "C-j") #'magit-visit-thing))

  (with-eval-after-load 'magit-mode
    (setopt magit-display-buffer-function #'magit-display-buffer-fullcolumn-most-v1))

  (with-eval-after-load 'magit-diff
    (setopt magit-diff-visit-prefer-worktree t))

  (defun my/magit-gh-pr-checkout (pr-number detach)
    (let* ((args (append '("pr" "checkout")
                         (when detach '("--detach"))
                         (list (number-to-string pr-number))))
           (cmd (string-join (cons "gh" args) " ")))
      (message "Executing: %s" cmd)
      (apply #'call-process "gh" nil nil nil args)
      (magit-refresh)))

  (defun my/magit-gh-pr-checkout-detach ()
    (interactive)
    (let ((pr (read-number "GitHub PR number (detach): ")))
      (my/magit-gh-pr-checkout pr t)))

  (defun my/magit-gh-pr-checkout-normal ()
    (interactive)
    (let ((pr (read-number "GitHub PR number (branch): ")))
      (my/magit-gh-pr-checkout pr nil)))

  (with-eval-after-load 'magit-branch
    (transient-append-suffix 'magit-branch "c"
      '("p" "Checkout PR (detach)" my/magit-gh-pr-checkout-detach))

    (transient-append-suffix 'magit-branch "c"
      '("P" "Checkout PR (branch)" my/magit-gh-pr-checkout-normal)))

(autoload-if-found '(git-gutter-mode) "git-gutter" nil t)

(with-eval-after-load 'git-gutter
  (setopt git-gutter:update-hooks '(after-save-hook after-revert-hook)))

(autoload-if-found '(git-gutter-fr:init
                     git-gutter-fr:view-diff-infos
                     git-gutter-fr:clear) "git-gutter-fringe" nil t)

(with-eval-after-load 'git-gutter
  (setopt git-gutter-fr:side 'right-fringe)
  (setopt git-gutter:window-width -1)
  (setopt git-gutter:init-function #'git-gutter-fr:init)
  (setopt git-gutter:view-diff-function #'git-gutter-fr:view-diff-infos)
  (setopt git-gutter:clear-function #'git-gutter-fr:clear))

(autoload-if-found '(git-timemachine) "git-timemachine" nil t)

(autoload-if-found '(gist-mode) "gist" nil t)

(autoload-if-found '(blamer-mode) "blamer" nil t)

(autoload-if-found '(git-auto-commit-mode) "git-auto-commit-mode" nil t)

(with-eval-after-load 'git-auto-commit-mode
  (setopt gac-automatically-push-p t)
  (setopt gac-silent-message-p t)
  (setopt gac-debounce-interval (* 60 60 3))
  (setopt gac-default-message "Update"))

  (autoload-if-found '(majutsu majutsu-log) "majutsu" nil t)

  (defun my/jj-checkout-pr (number)
    "Start a new jj change on top of the head branch of pull request NUMBER.
The head branch is fetched from origin and `jj new' is run on it in the
current jj repository.  A pull request from a fork is refused instead of
adding a remote."
    (interactive (list (read-number "PR number: ")))
    (let* ((root (let ((vcs (my/vcs-root default-directory)))
                   (if (eq (car vcs) 'jj)
                       (cdr vcs)
                     (user-error "Not inside a jj repository"))))
           (default-directory root)
           (url (or (my/jj-origin-url root)
                    (user-error "No origin remote in %s" root)))
           ;; a jj workspace has no .git, so gh cannot infer the repository
           (repo (replace-regexp-in-string "\\`https?://" "" (my/remote-url-to-https url)))
           (info (with-temp-buffer
                   (unless (zerop (call-process "gh" nil (list t nil) nil "pr" "view"
                                                (number-to-string number) "--repo" repo
                                                "--json" "headRefName,isCrossRepository"))
                     (user-error "gh pr view %d failed" number))
                   (goto-char (point-min))
                   (json-parse-string (buffer-string) :object-type 'alist
                                      :false-object nil :null-object nil)))
           (head (alist-get 'headRefName info)))
      (when (alist-get 'isCrossRepository info)
        (user-error "PR %d comes from a fork; add the remote manually" number))
      (unless (and (stringp head)
                   (string-match-p "\\`[A-Za-z0-9._/-]+\\'" head)
                   (not (string-prefix-p "-" head)))
        (user-error "PR %d has an unusable head branch name: %S" number head))
      (pcase-let ((`(,exit ,_ ,err) (my/jj-call root "git" "fetch" "--remote" "origin"
                                                "--branch" (concat "exact:" head))))
        (unless (zerop exit)
          (user-error "jj git fetch of %s failed: %s" head err)))
      (pcase-let ((`(,exit ,_ ,err) (my/jj-call root "new" (concat head "@origin"))))
        (unless (zerop exit)
          (user-error "jj new %s@origin failed: %s" head err)))
      (message "Checked out PR %d (%s@origin)" number head)))

(autoload-if-found '(key-chord-mode key-chord-define-global) "key-chord" nil t)

(add-hook 'after-init-hook #'key-chord-mode)
(add-hook 'after-init-hook #'(lambda ()
                               (key-chord-define-global "fj" #'view-mode)
                               (key-chord-define-global "jf" #'view-mode)))

(autoload-if-found '(key-combo-mode key-combo-define-local) "key-combo" nil t)

(with-eval-after-load 'php-mode
  )

(with-eval-after-load 'typescript-tsx-mode
  (add-hook 'typescript-tsx-mode
            #'(lambda ()
                (key-combo-mode)
                (key-combo-define-local (kbd "</") #'web-mode-element-close))))

(autoload-if-found '(which-key-mode) "which-key" nil t)

(add-hook 'after-init-hook #'which-key-mode)

(autoload-if-found '(global-dmacro-mode) "dmacro" nil t)

(add-hook 'after-init-hook #'global-dmacro-mode)

(autoload-if-found '(god-mode) "god-mode" nil t)

(autoload-if-found '(emr-show-refactor-menu) "emr" nil t)

(with-eval-after-load 'prog-mode
  (define-key prog-mode-map (kbd "M-RET") #'emr-show-refactor-menu))

(autoload-if-found '(yas-global-mode) "yasnippet" nil t)

(add-hook 'after-init-hook #'yas-global-mode)

(autoload-if-found '(consult-yasnippet) "consult-yasnippet" nil t)

(keymap-global-set "C-c y" #'consult-yasnippet)
(keymap-global-set "C-c C-y" #'consult-yasnippet)

(autoload-if-found '(soft-narrow-mode) "soft-narrow" nil t)

(add-hook 'after-init-hook #'soft-narrow-mode)

(autoload-if-found '(eglot-ensure) "eglot" nil t)

(with-eval-after-load 'eglot
  (setopt eglot-events-buffer-size nil)
  (setopt eglot-autoshutdown t)
  (setopt eglot-extend-to-xref t)

  (add-to-list 'eglot-server-programs
               '(typescript-mode . ("deno" "lsp"
                                    :initializationOptions (:deno (:enable t))))))

(autoload-if-found '(eglot-booster-mode) "eglot-booster" nil t)

(add-hook 'after-init-hook #'eglot-booster-mode)

(autoload-if-found '(lsp lsp-deferred lsp-org lsp-register-client make-lsp-client) "lsp-mode" nil t)
(autoload-if-found '(lsp-lens-mode lsp-lens-refresh lsp-lens--enable) "lsp-lens" nil t)
(autoload-if-found '(lsp-modeline-workspace-status-mode lsp-modeline-code-actions-mode) "lsp-modeline" nil t)
(autoload-if-found '(lsp-headerline-breadcrumb-mode) "lsp-headerline" nil t)
(autoload-if-found '(lsp-diagnostics-mode) "lsp-diagnostics" nil t)

(with-eval-after-load 'lsp-mode
  (add-to-list 'lsp-language-id-configuration '("php-ts-mode" . "php"))

  (advice-add 'lsp-rename :around #'my/advice-disable-buffer-readonly)
  (advice-add 'lsp-execute-code-action :around #'my/advice-disable-buffer-readonly)

  (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]vendor")
  (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]storage")
  (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]docs")
  (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]target")
  (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\].calva")
  (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\].clj-kondo")
  (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\].direnv")

  (add-hook 'lsp-mode-hook #'flycheck-mode)

  (add-hook 'lsp-configure-hook #'lsp-diagnostics-mode)

  (add-hook 'lsp-configure-hook #'corfu-mode)

  (setopt lsp-response-timeout 60)
  (setopt lsp-idle-delay 0.8)
  (setopt lsp-enable-links nil)
  (setopt lsp-log-io nil)
  (setopt lsp-file-watch-threshold 20000)
  (setopt lsp-client-packages (delq 'lsp-volar lsp-client-packages))
  (setopt lsp-modeline-code-actions-enable nil))

(with-eval-after-load 'lsp-diagnostics
  (setopt lsp-diagnostics-flycheck-default-level 'warning))

(with-eval-after-load 'lsp-completion
  (setopt lsp-completion-no-cache t)
  (setopt lsp-completion-provider :none))

(with-eval-after-load 'lsp-php
  (setopt lsp-intelephense-telemetry-enabled t)
  (setopt lsp-intelephense-files-exclude ["**/.git/**" "**/.svn/**" "**/.hg/**" "**/CVS/**" "**/.DS_Store/**"
                                          "**/node_modules/**" "**/bower_components/**" "**/vendor/**/{Test,test,Tests,tests}/**"
                                          "**/.direnv/**"]))

(with-eval-after-load 'lsp-javascript
  (setopt lsp-typescript-references-code-lens-enabled t)
  (setopt lsp-typescript-implementations-code-lens-enabled t)
  (setopt lsp-javascript-display-return-type-hints t)
  (setopt lsp-javascript-display-parameter-type-hints t)
  (setopt lsp-javascript-display-parameter-name-hints-when-argument-matches-name t)
  (setopt lsp-javascript-display-property-declaration-type-hints t)
  (setopt lsp-javascript-display-variable-type-hints t)

  (setopt lsp-clients-deno-enable-unstable t))

(with-eval-after-load 'lsp-ruby
  (setopt lsp-solargraph-autoformat t)
  (setopt lsp-solargraph-multi-root nil))

(with-eval-after-load 'lsp-nix
  (setopt lsp-disabled-clients '(nix-nil))
  (setopt lsp-nix-nixd-server-path "nixd")
  (setopt lsp-nix-nixd-formatting-command ["nixfmt-rfc-style"])
  (let ((flake-path (concat "builtins.getFlake \""
                            (my/ghq-repo-path "github.com/takeokunn/nixos-configuration")
                            "\"")))
    (setopt lsp-nix-nixd-nixpkgs-expr
            (format "import (%s).inputs.nixpkgs { }" flake-path))
    (setopt lsp-nix-nixd-nixos-options-expr
            (format "(%s).darwinConfigurations.M4-Max.options" flake-path))
    (setopt lsp-nix-nixd-home-manager-options-expr
            (format "(%s).darwinConfigurations.M4-Max.options.home-manager.users.type.getSubOptions []" flake-path))))

(with-eval-after-load 'lsp-copilot
  (setopt lsp-copilot-enabled nil))

(with-eval-after-load 'lsp-mode
  (lsp-register-client
   (make-lsp-client
    :new-connection (lsp-stdio-connection '("kakehashi"))
    :activation-fn (lsp-activate-on "markdown")
    :server-id 'kakehashi)))

(defun lsp-booster--advice-json-parse (old-fn &rest args)
  "Try to parse bytecode instead of json."
  (or
   (when (equal (following-char) ?#)
     (let ((bytecode (read (current-buffer))))
       (when (byte-code-function-p bytecode)
         (funcall bytecode))))
   (apply old-fn args)))

(advice-add (if (progn (require 'json)
                       (fboundp 'json-parse-buffer))
                'json-parse-buffer
              'json-read)
            :around
            #'lsp-booster--advice-json-parse)

(defun lsp-booster--advice-final-command (old-fn cmd &optional test?)
  "Prepend emacs-lsp-booster command to lsp CMD."
  (let ((orig-result (funcall old-fn cmd test?)))
    (if (and (not test?)                             ;; for check lsp-server-present?
             (not (file-remote-p default-directory)) ;; see lsp-resolve-final-command, it would add extra shell wrapper
             lsp-use-plists
             (not (functionp 'json-rpc-connection))  ;; native json-rpc
             (executable-find "emacs-lsp-booster"))
        (progn
          (when-let* ((command-from-exec-path (executable-find (car orig-result))))  ;; resolve command from exec-path (in case not found in $PATH)
            (setcar orig-result command-from-exec-path))
          (message "Using emacs-lsp-booster for %s!" orig-result)
          (cons "emacs-lsp-booster" orig-result))
      orig-result)))

(advice-add 'lsp-resolve-final-command :around #'lsp-booster--advice-final-command)

(with-eval-after-load 'lsp-mode
  (add-hook 'lsp-mode-hook #'(lambda () (require 'ccls))))

(with-eval-after-load 'lsp-php
  (setopt lsp-intelephense-licence-key "00OXTX8OROOJH9P"))

(autoload-if-found '(consult-lsp-symbols) "consult-lsp" nil t)

(with-eval-after-load 'lsp-mode
  (define-key lsp-mode-map [remap xref-find-apropos] #'consult-lsp-symbols))

(autoload-if-found '(lsp-treemacs-sync-mode) "lsp-treemacs" nil t)

(with-eval-after-load 'lsp-mode
  (add-hook 'lsp-mode-hook #'lsp-treemacs-sync-mode))

(with-eval-after-load 'lsp-treemacs
  (setopt lsp-treemacs-error-list-severity 1)
  (setopt lsp-treemacs-error-list-current-project-only t))

(with-eval-after-load 'lsp-mode
  (add-hook 'lsp-mode-hook #'(lambda ()
                             (require 'lsp-dart))))

(autoload-if-found '(dap-debug) "dap-mode" nil t)
(autoload-if-found '(dap-hydra) "dap-hydra" nil t)
(autoload-if-found '(dap-ui-mode dap-ui-controls-mode) "dap-ui" nil t)
(autoload-if-found '(dap-tooltip-mode) "dap-mouse" nil t)
(autoload-if-found '(dap-php-setup) "dap-php" nil t)
(autoload-if-found '(dap-node-setup) "dap-node" nil t)
(autoload-if-found '(dap-go-setup) "dap-go" nil t)
(autoload-if-found '(dap-ruby-setup) "dap-ruby" nil t)

(with-eval-after-load 'dap-mode
  (define-key dap-mode-map (kbd "C-c d") #'dap-breakpoint-toggle)

  (add-hook 'dap-mode-hook #'dap-ui-mode)
  (add-hook 'dap-mode-hook #'dap-ui-controls-mode)
  (add-hook 'dap-mode-hook #'tooltip-mode)
  (add-hook 'dap-mode-hook #'dap-tooltip-mode)
  (add-hook 'dap-stopped-hook #'(lambda (_arg) (call-interactively #'dap-hydra))))

(autoload-if-found '(lsp-ui-mode) "lsp-ui" nil t)

(with-eval-after-load 'lsp-mode
  (add-hook 'lsp-mode-hook #'lsp-ui-mode))

(with-eval-after-load 'lsp-ui-doc
  (setopt lsp-ui-doc-enable t)
  (setopt lsp-ui-doc-show-with-cursor t)
  (setopt lsp-ui-doc-use-webkit t)
  (setopt lsp-ui-doc-include-signature t)
  (setopt lsp-ui-doc-delay 1)
  (setopt lsp-ui-doc-max-height 30))

(autoload-if-found '(lsp-ui-peek-find-references lsp-ui-peek-find-definitions lsp-ui-peek-find-implementation) "lsp-ui-peek" nil t)
(with-eval-after-load 'lsp-ui-peek
  (setopt lsp-ui-peek-enable nil)
  (setopt lsp-ui-peek-peek-height 30)
  (setopt lsp-ui-peek-list-width 60)
  (setopt lsp-ui-peek-fontify 'on-demand))

(autoload-if-found '(lsp-ui-imenu) "lsp-ui-imenu" nil t)
(with-eval-after-load 'lsp-ui-imenu
  (setopt lsp-ui-imenu-enable nil)
  (setopt lsp-ui-imenu-kind-position 'top))

(autoload-if-found '(lsp-ui-sideline-mode) "lsp-ui-sideline" nil t)
(with-eval-after-load 'lsp-ui-sideline
  (setopt lsp-ui-sideline-enable nil)
  (setopt lsp-ui-sideline-show-hover t))

(with-eval-after-load 'lsp-mode
  (define-key lsp-mode-map (kbd "C-c C-r") #'lsp-ui-peek-find-references)
  (define-key lsp-mode-map (kbd "C-c C-j") #'lsp-ui-peek-find-definitions)
  (define-key lsp-mode-map (kbd "C-c C-i") #'lsp-ui-peek-find-implementation)
  (define-key lsp-mode-map (kbd "C-c C-m") #'lsp-ui-imenu)
  (define-key lsp-mode-map (kbd "C-c C-s") #'lsp-ui-sideline-mode)
  (define-key lsp-mode-map (kbd "C-c C-d") #'lsp-ui-doc-mode))

(autoload-if-found '(lsp-scheme) "lsp-scheme" nil t)

(with-eval-after-load 'scheme
  (add-hook 'scheme-mode-hook #'lsp-scheme))

(autoload-if-found '(global-syntax-subword-mode) "syntax-subword" nil t)

(add-hook 'after-init-hook #'global-syntax-subword-mode)

(autoload-if-found '(global-undo-tree-mode) "undo-tree" nil t)

(add-hook 'after-init-hook #'global-undo-tree-mode)

(with-eval-after-load 'undo-tree
  (setopt undo-tree-auto-save-history nil))

(with-eval-after-load 'prog-mode
  (add-hook 'prog-mode-hook #'view-mode))

(with-eval-after-load 'view
  (define-key view-mode-map (kbd "f") #'forward-char)
  (define-key view-mode-map (kbd "b") #'backward-char)
  (define-key view-mode-map (kbd "n") #'my/org-view-next-heading)
  (define-key view-mode-map (kbd "p") #'my/org-view-previous-heading)
  (define-key view-mode-map (kbd "@") #'set-mark-command)
  (define-key view-mode-map (kbd "C-c '") #'my/org-edit-special)
  (define-key view-mode-map (kbd "C-c C-C") #'my/org-ctrl-c-ctrl-c)
  (define-key view-mode-map (kbd "e") nil)
  (define-key view-mode-map (kbd "C-j") nil)
  (define-key view-mode-map (kbd "C-i") #'my/view-tab)
  (define-key view-mode-map (kbd "S-C-i") #'my/view-shifttab)

  (defun my/org-view-next-heading ()
    (interactive)
    (if (and (derived-mode-p 'org-mode)
             (org-at-heading-p))
        (org-next-visible-heading 1)
      (next-line)))

  (defun my/org-view-previous-heading ()
    (interactive)
    (if (and (derived-mode-p 'org-mode)
             (org-at-heading-p))
        (org-previous-visible-heading 1)
      (previous-line)))

  (defun my/view-tab ()
    (interactive)
    (when (and (derived-mode-p 'org-mode)
               (or (org-at-heading-p)
                   (org-at-property-drawer-p)))
      (let ((view-mode nil))
        (org-cycle))))

  (defun my/view-shifttab ()
    (interactive)
    (when (derived-mode-p 'org-mode)
      (let ((view-mode nil))
        (org-shifttab))))

  (defun my/org-edit-special ()
    (interactive)
    (when (derived-mode-p 'org-mode)
      (view-mode -1)
      (org-edit-special)))

  (defun my/org-ctrl-c-ctrl-c ()
    (interactive)
    (when (derived-mode-p 'org-mode)
      (view-mode -1)
      (org-ctrl-c-ctrl-c)))

  (defun my/disable-buffer-readonly ()
    (setq-local buffer-read-only nil))

  (defun my/advice-disable-buffer-readonly (old-func &rest args)
    (add-hook 'view-mode-hook #'my/disable-buffer-readonly)
    (apply old-func args)
    (remove-hook 'view-mode-hook #'my/disable-buffer-readonly)))

(with-eval-after-load 'comint
  (setopt comint-buffer-maximum-size 100000)
  (setopt comint-prompt-read-only t)
  (setopt comint-terminfo-terminal "eterm-256color"))

(autoload-if-found '(crux-open-with
                     crux-smart-open-line-above
                     crux-cleanup-buffer-or-region
                     crux-view-url
                     crux-transpose-windows
                     crux-duplicate-current-line-or-region
                     crux-duplicate-and-comment-current-line-or-region
                     crux-rename-file-and-buffer
                     crux-visit-term-buffer
                     crux-kill-other-buffers
                     crux-indent-defun
                     crux-top-join-lines
                     crux-kill-line-backwards) "crux" nil t)

(keymap-global-set "C-c o" #'crux-open-with)
(keymap-global-set "C-S-o" #'crux-smart-open-line-above)
(keymap-global-set "C-c u" #'crux-view-url)
(keymap-global-set "C-x 4 t" #'crux-transpose-windows)
(keymap-global-set "C-c d" #'crux-duplicate-current-line-or-region)
(keymap-global-set "C-c M-d" #'crux-duplicate-and-comment-current-line-or-region)
(keymap-global-set "C-c r" #'crux-rename-file-and-buffer)
(keymap-global-set "C-c M-t" #'crux-visit-term-buffer)
(keymap-global-set "C-c k" #'crux-kill-other-buffers)
(keymap-global-set "C-M-z" #'crux-indent-defun)
(keymap-global-set "C-^" #'crux-top-join-lines)
(keymap-global-set "C-DEL" #'crux-kill-line-backwards)

(autoload-if-found '(delete-selection-mode) "delsel" nil t)

(add-hook 'after-init-hook #'delete-selection-mode)

(autoload-if-found '(dogears-go
                     dogears-back
                     dogears-forward
                     dogears-list
                     dogears-sidebar) "dogears" nil t)

(keymap-global-set "M-g d" #'dogears-go)
(keymap-global-set "M-g M-b" #'dogears-back)
(keymap-global-set "M-g M-f" #'dogears-forward)
(keymap-global-set "M-g M-d" #'dogears-list)
(keymap-global-set "M-g M-D" #'dogears-sidebar)

(autoload-if-found '(goto-address-prog-mode goto-address-mode) "goto-address" nil t)

(with-eval-after-load 'prog-mode
  (add-hook 'prog-mode-hook #'goto-address-prog-mode))

(with-eval-after-load 'text-mode
  (add-hook 'text-mode-hook #'goto-address-mode))

(autoload-if-found '(minimap-mode) "minimap" nil t)

(keymap-global-set "C-c m" #'minimap-mode)

(with-eval-after-load 'minimap
  (setopt minimap-window-location 'right)
  (setopt minimap-update-delay 0.2)
  (setopt minimap-minimum-width 20)
  (setopt minimap-major-modes '(prog-mode org-mode)))

(autoload-if-found '(puni-global-mode puni-disable-puni-mode) "puni" nil t)

(add-hook 'after-init-hook #'puni-global-mode)

(with-eval-after-load 'lisp-mode
  (add-hook 'lisp-mode-hook #'puni-disable-puni-mode))

(with-eval-after-load 'emacs-lisp-mode
  (add-hook 'emacs-lisp-mode-hook #'puni-disable-puni-mode))

(with-eval-after-load 'clojure-mode
  (add-hook 'clojure-mode-hook #'puni-disable-puni-mode))

(with-eval-after-load 'lisp-interaction-mode
  (add-hook 'lisp-interacton-mode-hook #'puni-disable-puni-mode))

(with-eval-after-load 'scheme
  (add-hook 'scheme-mode-hook #'puni-disable-puni-mode))

(with-eval-after-load 'simple
  (add-hook 'eval-expression-minibuffer-setup-hook #'puni-disable-puni-mode))

(with-eval-after-load 'ielm
  (add-hook 'inferior-emacs-lisp-mode-hook #'puni-disable-puni-mode))

(with-eval-after-load 'minibuffer
  (add-hook 'minibuffer-mode-hook #'puni-disable-puni-mode))

(autoload-if-found '(quickrun) "quickrun" nil t)

(autoload-if-found '(restclient-mode) "restclient" nil t)

(autoload-if-found '(smart-jump-setup-default-registers) "smart-jump" nil t)

(add-hook 'after-init-hook #'smart-jump-setup-default-registers)

(autoload-if-found '(string-inflection-all-cycle) "string-inflection" nil t)

(autoload-if-found '(uuid-string) "uuid" nil t)

(defun my/uuid ()
  (interactive)
  (insert (uuid-string)))

(autoload-if-found '(woman woman-find-file) "woman" nil t)

(autoload-if-found '(proced) "proced" nil t)

(with-eval-after-load 'proced
  (add-hook 'proced-mode-hook #'proced-toggle-auto-update)

  (setopt proced-auto-update-interval 10)
  (setopt proced-tree-flag t)
  (setopt proced-format 'long))

(autoload-if-found '(proced-narrow) "proced-narrow" nil t)

(with-eval-after-load 'proced
  (define-key proced-mode-map (kbd "/") #'proced-narrow))

(autoload-if-found '(symon-mode) "symon" nil t)

(autoload-if-found '(clm/toggle-command-log-buffer) "command-log-mode" nil t)

(defalias 'command-log #'clm/toggle-command-log-buffer)

(autoload-if-found '(esup) "esup" nil t)

(autoload-if-found '(explain-pause-mode) "explain-pause-mode" nil t)

(autoload-if-found '(disk-usage disk-usage-here) "disk-usage" nil t)

(autoload-if-found '(keyfreq-mode keyfreq-autosave-mode) "keyfreq" nil t)

(add-hook 'after-init-hook #'keyfreq-mode)
(add-hook 'after-init-hook #'keyfreq-autosave-mode)

(autoload-if-found '(uptimes) "uptimes" nil t)

(unless (eq system-type 'darwin)
  (autoload-if-found '(mu4e) "mu4e" nil t)

  (keymap-global-set "C-x C-w" #'mu4e)

  (with-eval-after-load 'mu4e
    (setopt mail-user-agent 'mu4e-user-agent))

  (with-eval-after-load 'mu4e-update
    (setopt mu4e-get-mail-command "offlineimap")
    (setopt mu4e-update-interval (* 1 60))
    (setopt mu4e-index-cleanup nil)
    (setopt mu4e-index-lazy-check t))

  (with-eval-after-load 'mu4e-view
    (setopt mu4e-split-view 'horizontal))

  (with-eval-after-load 'mu4e-folders
    (setopt mu4e-maildir-shortcuts '((:maildir "/Gmail/INBOX" :key ?i)
                                     (:maildir "/Gmail/Emacs" :key ?e)
                                     (:maildir "/Gmail/GitHub" :key ?h)
                                     (:maildir "/Gmail/Guix" :key ?g)
                                     (:maildir "/Gmail/PHP" :key ?p))))

  (with-eval-after-load 'mm-decode
    (add-to-list 'mm-discouraged-alternatives "text/html")
    (add-to-list 'mm-discouraged-alternatives "text/richtext")))

(unless (eq system-type 'darwin)
  (autoload-if-found '() "mu4e-views" nil t))

(unless (eq system-type 'darwin)
  (autoload-if-found '(mu4e-dashboard) "mu4e-dashboard" nil t)

  (with-eval-after-load 'mu4e-dashboard
    (setopt mu4e-dashboard-file "~/.emacs.d/misc/mu4e-dashboard.org")))

(autoload-if-found '(google-translate-at-point) "google-translate" nil t)

(autoload-if-found '(md4rd
                     md4rd-login
                     md4rd-visit
                     md4rd-widget-expand-all
                     md4rd-widget-collapse-all
                     md4rd-reply
                     md4rd-upvote
                     md4rd-downvote
                     md4rd-widget-toggle-line
                     md4rd-refresh-login
                     md4rd-indent-all-the-lines) "md4rd" nil t)

(with-eval-after-load 'md4rd
  (add-hook 'md4rd-mode-hook #'md4rd-indent-all-the-lines)
  (run-with-timer 0 3540 #'md4rd-refresh-login)

  (setopt md4rd-subs-active '(emacs lisp+Common_Lisp prolog clojure))

  (define-key md4rd-mode-map (kbd "u") 'tree-mode-goto-parent)
  (define-key md4rd-mode-map (kbd "o") 'md4rd-open)
  (define-key md4rd-mode-map (kbd "v") 'md4rd-visit)
  (define-key md4rd-mode-map (kbd "e") 'tree-mode-toggle-expand)
  (define-key md4rd-mode-map (kbd "E") 'md4rd-widget-expand-all)
  (define-key md4rd-mode-map (kbd "C") 'md4rd-widget-collapse-all)
  (define-key md4rd-mode-map (kbd "n") 'widget-forward)
  (define-key md4rd-mode-map (kbd "j") 'widget-forward)
  (define-key md4rd-mode-map (kbd "h") 'backward-button)
  (define-key md4rd-mode-map (kbd "p") 'widget-backward)
  (define-key md4rd-mode-map (kbd "k") 'widget-backward)
  (define-key md4rd-mode-map (kbd "l") 'forward-button)
  (define-key md4rd-mode-map (kbd "q") 'kill-current-buffer)
  (define-key md4rd-mode-map (kbd "r") 'md4rd-reply)
  (define-key md4rd-mode-map (kbd "u") 'md4rd-upvote)
  (define-key md4rd-mode-map (kbd "d") 'md4rd-downvote)
  (define-key md4rd-mode-map (kbd "t") 'md4rd-widget-toggle-line))

(defconst my/enable-warning-log nil)

(defun set-fontset-font:around (set-fontset-font name target font-spec &optional frame add)
  "Warn if specified font is not installed."
  (if (stringp font-spec)
      (setopt font-spec (font-spec :family font-spec)))
  (if (and (fontp font-spec)
           (null (find-font font-spec))
           my/enable-warning-log)
      (warn "set-fontset-font: font %s is not found." (font-get font-spec :family))
    (ignore-errors
      (funcall set-fontset-font name target font-spec frame add))))

;; reset all settings in default fontset
(add-hook 'after-init-hook
          #'(lambda ()
              (advice-add 'set-fontset-font :around #'set-fontset-font:around)

              ;; Set default font size to 13pt (height is in 1/10pt units, match kitty)
              (set-face-attribute 'default nil :height 130)

              (when (functionp 'set-fontset-font)
                (if (find-font (font-spec :family "Noto Sans"))
                    (set-fontset-font t '(0 . #x3fffff) "Noto Sans"))

                (set-fontset-font t 'latin "Noto Sans")
                (set-fontset-font t 'greek "Noto Sans")
                (set-fontset-font t 'phonetic "Noto Sans")
                (set-fontset-font t 'coptic "Noto Sans Coptic")
                (set-fontset-font t 'coptic "Noto Sans Symbols2" nil 'append)
                (set-fontset-font t 'cyrillic "Noto Sans")
                (set-fontset-font t 'armenian "Noto Sans Armenian")
                (set-fontset-font t 'hebrew "Noto Sans Hebrew")
                (set-fontset-font t 'arabic "Noto Sans Arabic")
                (set-fontset-font t 'syriac "Noto Sans Syriac")
                (set-fontset-font t 'thaana "Noto Sans Thaana")
                (set-fontset-font t 'nko "Noto Sans N'Ko")
                (set-fontset-font t 'samaritan "Noto Sans Samaritan")
                (set-fontset-font t 'mandaic "Noto Sans Mandaic")
                (set-fontset-font t 'devanagari "Noto Sans Devanagari")
                (set-fontset-font t 'bengali "Noto Sans Bengali")
                (set-fontset-font t 'gurmukhi "Noto Sans Gurmukhi")
                (set-fontset-font t 'gujarati "Noto Sans Gujanrati")
                (set-fontset-font t 'oriya "Noto Sans Oriya")
                (set-fontset-font t 'tamil "Noto Sans Tamil")
                (set-fontset-font t 'tamil "Noto Sans Tamil Supplement" nil 'append)
                (set-fontset-font t 'telugu "Noto Sans Telugu")
                (set-fontset-font t 'kannada "Noto Sans Kannada")
                (set-fontset-font t 'malayalam "Noto Sans Malayalam")
                (set-fontset-font t 'sinhala "Noto Sans Sinhala")
                (set-fontset-font t 'thai "Noto Sans Thai")
                (set-fontset-font t 'lao "Noto Sans Lao")
                (set-fontset-font t 'tibetan "Noto Sans Tibetan")
                (set-fontset-font t 'burmese "Noto Sans Myanmar")
                (set-fontset-font t 'georgian "Noto Sans Georgian")
                (set-fontset-font t 'hangul "Noto Sans CJK KR")
                (set-fontset-font t 'ethiopic "Noto Sans Ethiopic")
                (set-fontset-font t 'cherokee "Noto Sans Cherokee")
                (set-fontset-font t 'canadian-aboriginal "Noto Sans Canadian Aboriginal")
                (set-fontset-font t 'ogham "Noto Sans Ogham")
                (set-fontset-font t 'runic "Noto Sans Runic")
                (set-fontset-font t 'tagalog "Noto Sans Tagalog")
                (set-fontset-font t 'hanunoo "Noto Sans Hanunoo")
                (set-fontset-font t 'buhid "Noto Sans Buhid")
                (set-fontset-font t 'tagbanwa "Noto Sans Tagbanwa")
                (set-fontset-font t 'khmer "Noto Sans Khmer")
                (set-fontset-font t 'mongolian "Noto Sans Mongolian")
                (set-fontset-font t 'limbu "Noto Sans Limbu")
                (set-fontset-font t 'tai-le "Noto Sans Tai Le")
                (set-fontset-font t 'tai-lue "Noto Sans NewTaiLue")
                (set-fontset-font t 'buginese "Noto Sans Buginese")
                (set-fontset-font t 'tai-tham "Noto Sans Tai Tham")
                (set-fontset-font t 'balinese "Noto Sans Balinese")
                (set-fontset-font t 'sundanese "Noto Sans Sundanese")
                (set-fontset-font t 'vedic "Noto Sans Devanagari")
                (set-fontset-font t 'symbol "Noto Color Emoji")
                (set-fontset-font t 'symbol "Noto Sans CJK JP" nil 'append)
                (set-fontset-font t 'symbol "Noto Sans Symbols2" nil 'append)
                (set-fontset-font t 'symbol "Noto Sans" nil 'append)
                (set-fontset-font t 'symbol "Noto Sans Math" nil 'append)
                (set-fontset-font t 'symbol "Noto Sans Symbols" nil 'append)
                (set-fontset-font t 'braille "Noto Sans Symbols2")
                (set-fontset-font t 'batak "Noto Sans Batak")
                (set-fontset-font t 'lepcha "Noto Sans Lepcha")
                (set-fontset-font t 'ol-chiki "Noto Sans Ol Chiki")
                (set-fontset-font t 'glagolitic "Noto Sans Glagolitic")
                (set-fontset-font t 'tifinagh "Noto Sans Tifinagh")
                (set-fontset-font t 'han "Noto Sans CJK JP")
                (set-fontset-font t 'ideographic-description "Noto Sans CJK JP")
                (set-fontset-font t 'cjk-misc "Noto Sans CJK JP")
                (set-fontset-font t 'kana "Noto Sans CJK JP")
                (set-fontset-font t 'bopomofo "Noto Sans CJK TC")
                (set-fontset-font t 'kanbun "Noto Sans CJK JP")
                (set-fontset-font t 'yi "Noto Sans Yi")
                (set-fontset-font t 'lisu "Noto Sans Lisu")
                (set-fontset-font t 'vai "Noto Sans Vai")
                (set-fontset-font t 'bamum "Noto Sans Bamum")
                (set-fontset-font t 'syloti-nagri "Noto Sans Syloti Nagri")
                (set-fontset-font t 'north-indic-number "Noto Sans Devanagari")
                (set-fontset-font t 'phags-pa "Noto Sans Phags Pa")
                (set-fontset-font t 'saurashtra "Noto Sans Saurashtra")
                (set-fontset-font t 'kayah-li "Noto Sans Kayah Li")
                (set-fontset-font t 'rejang "Noto Sans Rejang")
                (set-fontset-font t 'javanese "Noto Sans Javanese")
                (set-fontset-font t 'cham "Noto Sans Cham")
                (set-fontset-font t 'tai-viet "Noto Sans Tai Viet")
                (set-fontset-font t 'meetei-mayek "Noto Sans Meetei Mayek")
                (set-fontset-font t 'vertical-form "Noto Sans CJK JP")
                (set-fontset-font t '(#xfe50 . #xfe6b) "Noto Sans CJK JP")
                (set-fontset-font t '(#xfff9 . #xfffb) "Noto Sans Symbols2")
                (set-fontset-font t 'linear-b "Noto Sans Linear B")
                (set-fontset-font t 'aegean-number "Noto Sans Linear B")
                (set-fontset-font t 'ancient-greek-number "Noto Sans Symbols2")
                (set-fontset-font t 'ancient-symbol "Noto Sans Symbols2")
                (set-fontset-font t 'phaistos-disc "Noto Sans Symbols2")
                (set-fontset-font t 'lycian "Noto Sans Lycian")
                (set-fontset-font t 'carian "Noto Sans Carian")
                (set-fontset-font t 'old-italic "Noto Sans Old Italic")
                (set-fontset-font t 'gothic "Noto Sans Gothic")
                (set-fontset-font t 'old-permic "Noto Sans Old Permic")
                (set-fontset-font t 'ugaritic "Noto Sans Ugaritic")
                (set-fontset-font t 'old-persian "Noto Sans OldPersian")
                (set-fontset-font t 'deseret "Noto Sans Deseret")
                (set-fontset-font t 'shavian "Noto Sans Shavian")
                (set-fontset-font t 'osmanya "Noto Sans Osmanya")
                (set-fontset-font t 'osage "Noto Sans Osage")
                (set-fontset-font t 'elbasan "Noto Sans Elbasan")
                (set-fontset-font t 'caucasian-albanian "Noto Sans CaucAlban")
                (set-fontset-font t 'linear-a "Noto Sans Linear A")
                (set-fontset-font t 'cypriot-syllabary "Noto Sans Cypriot")
                (set-fontset-font t 'aramaic "Noto Sans ImpAramaic")
                (set-fontset-font t 'palmyrene "Noto Sans Palmyrene")
                (set-fontset-font t 'nabataean "Noto Sans Nabataean")
                (set-fontset-font t 'hatran "Noto Sans Hatran")
                (set-fontset-font t 'phoenician "Noto Sans Phoenician")
                (set-fontset-font t 'lydian "Noto Sans Lydian")
                (set-fontset-font t 'meroitic "Noto Sans Meroitic")
                (set-fontset-font t 'kharoshthi "Noto Sans Kharoshthi")
                (set-fontset-font t 'old-south-arabian "Noto Sans OldSouArab")
                (set-fontset-font t 'old-north-arabian "Noto Sans OldNorArab")
                (set-fontset-font t 'manichaean "Noto Sans Manichaean")
                (set-fontset-font t 'avestan "Noto Sans Avestan")
                (set-fontset-font t 'inscriptional-parthian "Noto Sans Inscriptional Parthian")
                (set-fontset-font t 'inscriptional-pahlavi "Noto Sans Inscriptional Pahlavi")
                (set-fontset-font t 'psalter-pahlavi "Noto Sans PsaPahlavi")
                (set-fontset-font t 'old-turkic "Noto Sans Old Turkic")
                (set-fontset-font t 'old-hungarian "Noto Sans OldHung")
                (set-fontset-font t 'hanifi-rohingya "Noto Sans HanifiRohg")
                (set-fontset-font t 'rumi-number "Noto Sans Symbols2")
                (set-fontset-font t 'old-sogdian "Noto Sans OldSogdian")
                (set-fontset-font t 'sogdian "Noto Sans Sogdian")
                (set-fontset-font t 'elymaic "Noto Sans Elymaic")
                (set-fontset-font t 'brahmi "Noto Sans Brahmi")
                (set-fontset-font t 'kaithi "Noto Sans Kaithi")
                (set-fontset-font t 'sora-sompeng "Noto Sans SoraSomp")
                (set-fontset-font t 'chakma "Noto Sans Chakma")
                (set-fontset-font t 'mahajani "Noto Sans Mahajani")
                (set-fontset-font t 'sharada "Noto Sans Sharada")
                (set-fontset-font t 'sinhala-archaic-number "Noto Sans Sinhala")
                (set-fontset-font t 'khojki "Noto Sans Khojki")
                (set-fontset-font t 'multani "Noto Sans Multani")
                (set-fontset-font t 'khudawadi "Noto Sans Khudawadi")
                (set-fontset-font t 'grantha "Noto Sans Grantha")
                (set-fontset-font t 'newa "Noto Sans Newa")
                (set-fontset-font t 'tirhuta "Noto Sans Tirhuta")
                (set-fontset-font t 'siddham "Noto Sans Siddham")
                (set-fontset-font t 'modi "Noto Sans Modi")
                (set-fontset-font t 'takri "Noto Sans Takri")
                (set-fontset-font t 'ahom "Noto Serif Ahom")
                (set-fontset-font t 'dogra "Noto Serif Dogra")
                (set-fontset-font t 'warang-citi "Noto Sans WarangCiti")
                (set-fontset-font t 'zanabazar-square "Noto Sans Zanabazar")
                (set-fontset-font t 'soyombo "Noto Sans Soyombo")
                (set-fontset-font t 'pau-cin-hau "Noto Sans PauCinHau")
                (set-fontset-font t 'bhaiksuki "Noto Sans Bhaiksuki")
                (set-fontset-font t 'marchen "Noto Sans Marchen")
                (set-fontset-font t 'masaram-gondi "Noto Sans Masaram Gondi")
                (set-fontset-font t 'gunjala-gondi "Noto Sans Gunjala Gondi")
                (set-fontset-font t 'cuneiform "Noto Sans Cuneiform")
                (set-fontset-font t 'cuneiform-numbers-and-punctuation "Noto Sans Cuneiform")
                (set-fontset-font t 'egyptian "Noto Sans EgyptHiero")
                (set-fontset-font t 'anatolian "Noto Sans AnatoHiero")
                (set-fontset-font t 'mro "Noto Sans Mro")
                (set-fontset-font t 'bassa-vah "Noto Sans Bassa Vah")
                (set-fontset-font t 'pahawh-hmong "Noto Sans Pahawh Hmong")
                (set-fontset-font t 'miao "Noto Sans Miao")
                (set-fontset-font t 'tangut "Noto Serif Tangut")
                (set-fontset-font t 'tangut-components "Noto Serif Tangut")
                (set-fontset-font t '(#x16fe0 . #x16fe0) "Noto Serif Tangut")
                (set-fontset-font t 'duployan-shorthand "Noto Sans Duployan")
                (set-fontset-font t 'byzantine-musical-symbol "Noto Music")
                (set-fontset-font t 'musical-symbol "Noto Music")
                (set-fontset-font t 'ancient-greek-musical-notation "Noto Music")
                (set-fontset-font t 'mayan-numeral "Noto Sans Mayan Numerals")
                (set-fontset-font t 'tai-xuan-jing-symbol "Noto Sans Symbols2")
                (set-fontset-font t 'counting-rod-numeral "Noto Sans Symbols2")
                (set-fontset-font t 'mathematical "Noto Sans Math")
                (set-fontset-font t 'wancho "Noto Sans Wancho")
                (set-fontset-font t 'mende-kikakui "Noto Sans Mende Kikakui")
                (set-fontset-font t 'adlam "Noto Sans Adlam")
                (set-fontset-font t 'indic-siyaq-number "Noto Sans Indic Siyaq Numbers")
                (set-fontset-font t '(#x1ee00 . #x1eeff) "Noto Sans Math")
                (set-fontset-font t 'mahjong-tile "Noto Sans Symbols2")
                (set-fontset-font t 'domino-tile "Noto Sans Symbols2")
                (set-fontset-font t 'playing-cards "Noto Sans Symbols2")

                (set-fontset-font t 'kana "UniHentaiKana" nil 'append)
                (set-fontset-font t 'latin "HackGenNerd" nil 'append)
                (set-fontset-font t 'symbol "HackGenNerd" nil 'append)

                ;; Nerd Font (defined thru -#xfd46)
                (set-fontset-font t '( #xe000 .  #xf136) "Inconsolata Nerd Font"))))

(autoload-if-found '(font-lock-studio) "font-lock-studio" nil t)

(autoload-if-found '(ansi-color-for-comint-mode-on) "ansi-color" nil t)

(with-eval-after-load 'shell-mode
  (add-hook 'shell-mode-hook #'ansi-color-for-comint-mode-on))

(with-eval-after-load 'compile
  (add-hook 'compilation-filter-hook
            #'(lambda ()
                (ansi-color-apply-on-region (point-min) (point-max)))))

(autoload-if-found '(highlight-indent-guides-mode) "highlight-indent-guides" nil t)

(autoload-if-found '(global-hl-todo-mode) "hl-todo" nil t)

(add-hook 'after-init-hook #'global-hl-todo-mode)

(with-eval-after-load 'hl-todo
  (setopt hl-todo-keyword-faces
          '(("HOLD" . "#d0bf8f")
            ("TODO" . "#cc9393")
            ("NOW" . "#dca3a3")
            ("SOMEDAY" . "#dc8cc3")
            ("WAIT" . "#7cb8bb")
            ("REVIEW" . "e60a39")
            ("QA" . "#88CF88")
            ("DONE" . "#afd8af")
            ("FIXME" . "#cc9393")
            ("MEMO" . "#coffee"))))

(autoload-if-found '(xterm-color-filter) "xterm-color" nil t)

(add-hook 'after-init-hook
          #'(lambda () (setenv "TERM" "xterm-256color")))

(with-eval-after-load 'xterm-color
  (setopt xterm-color-preserve-properties t))

(autoload-if-found '(global-emojify-mode) "emojify" nil t)

(autoload-if-found '(nerd-icons-dired-mode) "nerd-icons-dired" nil t)

(with-eval-after-load 'dired-mode
  (add-hook 'dired-mode-hook #'nerd-icons-dired-mode))

(autoload-if-found '(nerd-icons-completion-marginalia-setup) "nerd-icons-completion" nil t)

(with-eval-after-load 'marginalia
  (add-hook 'marginalia-mode-hook #'nerd-icons-completion-marginalia-setup))

(add-hook 'after-init-hook
          #'(lambda ()
              (when (require 'doom-themes)
                (let ((theme 'doom-dracula))
                  (load-theme theme t)
                  ;; workaround a mutual face-inheritance cycle between gnus-group-news-low(-empty) in doom-themes;
                  ;; must fix here since gnus-group.el loads lazily and would error before any hook could run
                  (custom-theme-set-faces
                   theme '(gnus-group-news-low-empty ((t :inherit nil))))
                  (enable-theme theme)
                  (set-cursor-color "#f8f8f2")))))

(with-eval-after-load 'doom-themes
  (setopt doom-themes-padded-modeline t)
  (setopt doom-themes-enable-bold t)
  (setopt doom-themes-enable-italic t))

(autoload-if-found '(doom-modeline-mode) "doom-modeline" nil t)

(add-hook 'after-init-hook #'doom-modeline-mode)
(add-hook 'after-init-hook #'(lambda () (line-number-mode 0)))
(add-hook 'after-init-hook #'(lambda () (column-number-mode 0)))

(with-eval-after-load 'doom-modeline
  (setopt doom-modeline-buffer-file-name-style 'truncate-with-project)
  (setopt doom-modeline-icon t)
  (setopt doom-modeline-major-mode-icon t)
  (setopt doom-modeline-minor-modes nil)
  (setopt doom-modeline-check-icon nil)
  ;; doom-modeline-def-segment is a macro; with-eval-after-load doesn't defer compile-time macroexpansion
  (eval-when-compile (require 'doom-modeline))
  (doom-modeline-def-segment my/nskk
    "NSKK input mode indicator."
    (when (and (bound-and-true-p nskk-mode)
               (fboundp 'nskk-modeline-indicator))
      (nskk-modeline-indicator)))
  (let ((main-segments
         (append '(compilation objed-state misc-info project-name persp-name battery grip irc)
                 (when (not (eq system-type 'darwin))
                   '(mu4e))
                 (when (not (eq system-type 'darwin))
                   '(gnus))
                 '(github debug repl lsp my/nskk minor-modes input-method indent-info buffer-encoding major-mode process vcs check time))))
    (doom-modeline-def-modeline 'main
      '(eldoc bar window-state workspace-name window-number modals matches follow buffer-info remote-host buffer-position word-count parrot selection-info)
      main-segments))
  ;; emacsclient -c でGUIフレームが生成されたとき modeline を再描画する
  (add-hook 'after-make-frame-functions
            #'(lambda (frame)
                (when (display-graphic-p frame)
                  (doom-modeline-refresh-bars)))))

(autoload-if-found '(hacker-typer) "hacker-typer" nil t)

(autoload-if-found '(power-mode) "power-mode" nil t)

(autoload-if-found '(sudden-death) "sudden-death" nil t)

(autoload-if-found '(arto-open arto-version) "arto" nil t)

(with-eval-after-load 'arto
  (setopt arto-path "/Applications/Arto.app"))

(autoload-if-found '(redacted-mode) "redacted" nil t)

(defun my/redacted-mode ()
  (interactive)
  (read-only-mode (if redacted-mode -1 1))
  (redacted-mode (if redacted-mode -1 1)))

(autoload-if-found '(lorem-ipsum-insert-sentences
                     lorem-ipsum-insert-paragraphs
                     lorem-ipsum-insert-list) "lorem-ipsum" nil t)

(keymap-global-set "C-c C-l s" #'lorem-ipsum-insert-sentences)
(keymap-global-set "C-c C-l p" #'lorem-ipsum-insert-paragraphs)
(keymap-global-set "C-c C-l l" #'lorem-ipsum-insert-list)

(autoload-if-found '(zalgo-transform-word
                     zalgo-mode
                     zalgo-transform-region) "zalgo-mode" nil t)

(autoload-if-found '(pass pass-view-mode) "pass" nil t)

(add-to-list 'auto-mode-alist (cons (concat (regexp-quote (my/ghq-repo-path "github.com/takeokunn-private/private-pass")) "/current/.*\\.gpg") 'pass-view-mode))

(with-eval-after-load 'pass
  (setopt pass-suppress-confirmations t))

(autoload-if-found '(password-generator-simple
                     password-generator-strong
                     password-generator-paranoid
                     password-generator-numeric
                     password-generator-phonetic
                     password-generator-custom) "password-generator" nil t)

(autoload-if-found '(sops-save-file
                     sops-cancel
                     sops-edit-file
                     global-sops-mode) "sops" nil t)

(add-hook 'after-init-hook #'global-sops-mode)

(defun my/define-word ()
  (interactive)
  (if (use-region-p)
      (call-interactively #'define-word-at-point)
    (call-interactively #'define-word)))

(with-eval-after-load 'define-word
  (setopt define-word-displayfn-alist
          '((wordnik . takeokunn/define-word--display-in-buffer)
            (openthesaurus . takeokunn/define-word--display-in-buffer)
            (webster . takeokunn/define-word--display-in-buffer)
            (weblio . takeokunn/define-word--display-in-buffer))))

(autoload-if-found '(gcmh-mode) "gcmh" nil t)

(add-hook 'after-init-hook #'gcmh-mode)

(with-eval-after-load 'gcmh
  (setopt gcmh-verbose nil)

  (defvar my/gcmh-status nil)
  (advice-add #'garbage-collect
              :before
              (defun my/gcmh-log-start (&rest _)
                (when gcmh-verbose
                  (setopt my/gcmh-status "Running GC..."))))

  (advice-add #'gcmh-message
              :override
              (defun my/gcmh-message (format-string &rest args)
                (setopt my/gcmh-status
                      (apply #'format-message format-string args))
                (run-with-timer 2 nil
                                (lambda ()
                                  (setopt my/gcmh-status nil))))))

(autoload-if-found '(epa-file-enable) "epa-file" nil t)

(add-hook 'after-init-hook #'epa-file-enable)

(fset 'epg-wait-for-status 'ignore)

(with-eval-after-load 'epa-hook
  (setopt epa-file-encrypt-to '("bararararatty@gmail.com")))

(with-eval-after-load 'epa-file
  (setopt epa-file-select-keys 'silent)
  (setopt epa-file-cache-passphrase-for-symmetric-encryption t))

(with-eval-after-load 'epg-config
  (setopt epg-pinentry-mode 'loopback))

(autoload-if-found '(pinentry-start) "pinentry" nil t)

(autoload-if-found '(helpful-callable
                     helpful-function
                     helpful-macro
                     helpful-command
                     helpful-key
                     helpful-variable
                     helpful-at-point) "helpful" nil t)

(keymap-global-set "C-h f" #'helpful-callable)
(keymap-global-set "C-h v" #'helpful-variable)
(keymap-global-set "C-h k" #'helpful-key)
(keymap-global-set "C-c C-d" #'helpful-at-point)
(keymap-global-set "C-h F" #'helpful-function)
(keymap-global-set "C-h C" #'helpful-command)

(autoload-if-found '(exec-path-from-shell-initialize) "exec-path-from-shell")

;; Configure variables BEFORE initialization
(setopt exec-path-from-shell-arguments '("-l"))
(setopt exec-path-from-shell-variables '("PATH" "TERM" "COPILOT_LANGUAGE_SERVER_PATH"))

(exec-path-from-shell-initialize)

;; Explicitly set SSH_AUTH_SOCK for GPG agent (exec-path-from-shell doesn't handle this correctly on macOS)
(setenv "SSH_AUTH_SOCK" (expand-file-name "~/.gnupg/S.gpg-agent.ssh"))

(with-eval-after-load 'htmlize
  (setopt htmlize-html-charset 'utf-8))

(autoload-if-found '(midnight-mode) "midnight" nil t)

(add-hook 'after-init-hook #'midnight-mode)

(with-eval-after-load 'midnight
  (setopt clean-buffer-list-delay-general 1))

(autoload-if-found '(lte-truncate-table-mode) "lte" nil t)

(with-eval-after-load 'markdown-mode
  (add-hook 'markdown-mode-hook #'lte-truncate-table-mode))

(with-eval-after-load 'org
  (add-hook 'org-mode-hook #'lte-truncate-table-mode))

(autoload-if-found '(inhibit-mouse-mode) "inhibit-mouse" nil t)

(add-hook 'after-init-hook #'inhibit-mouse-mode)

(autoload-if-found '(pdf-tools-install) "pdf-tools" nil t)
(autoload-if-found '(pdf-occur-global-minor-mode) "pdf-occur" nil t)

(add-hook 'after-init-hook
          (lambda ()
            (condition-case err
                (pdf-tools-install t)
              (error (message "pdf-tools-install failed: %s" (error-message-string err))))))

(autoload-if-found '(dumb-jump-mode
                     dumb-jump-xref-activate
                     dumb-jump-go
                     dumb-jump-back) "dumb-jump" nil t)

(add-hook 'after-init-hook #'dumb-jump-mode)

(with-eval-after-load 'xref
  (add-hook 'xref-backend-functions #'dumb-jump-xref-activate))

(with-eval-after-load 'dumb-jump
  (setopt dumb-jump-force-searcher 'rg)
  (setopt dumb-jump-prefer-searcher 'rg)
  (setopt dumb-jump-default-project "")
  (setopt dumb-jump-disable-obsolete-warnings t))

(autoload-if-found '(enable-paredit-mode
                     paredit-forward-slurp-sexp
                     paredit-splice-sexp
                     paredit-define-keys)
                   "paredit" nil t)

(keymap-global-set "C-c f" #'paredit-forward-slurp-sexp)
(keymap-global-set "M-s" #'paredit-splice-sexp)

(with-eval-after-load 'paredit
  (add-hook 'paredit-mode-hook #'paredit-define-keys))

(with-eval-after-load 'lisp-mode
  (add-hook 'lisp-mode-hook #'enable-paredit-mode)
  (add-hook 'lisp-data-mode-hook #'enable-paredit-mode))

(with-eval-after-load 'emacs-lisp-mode
  (add-hook 'emacs-lisp-mode-hook #'enable-paredit-mode))

(with-eval-after-load 'clojure-mode
  (add-hook 'clojure-mode-hook #'enable-paredit-mode))

(with-eval-after-load 'lisp-interaction-mode
  (add-hook 'lisp-interacton-mode-hook #'enable-paredit-mode))

(with-eval-after-load 'scheme
  (add-hook 'scheme-mode-hook #'enable-paredit-mode))

(with-eval-after-load 'simple
  (add-hook 'eval-expression-minibuffer-setup-hook #'enable-paredit-mode))

(with-eval-after-load 'ielm
  (add-hook 'inferior-emacs-lisp-mode-hook #'enable-paredit-mode))

(autoload-if-found '(rainbow-delimiters-mode-enable) "rainbow-delimiters" nil t)

(with-eval-after-load 'lisp-mode
  (add-hook 'lisp-mode-hook #'rainbow-delimiters-mode-enable))

(with-eval-after-load 'emacs-lisp-mode
  (add-hook 'emacs-lisp-mode-hook #'rainbow-delimiters-mode-enable))

(with-eval-after-load 'clojure-mode
  (add-hook 'clojure-mode-hook #'rainbow-delimiters-mode-enable))

(with-eval-after-load 'scheme
  (add-hook 'scheme-mode-hook #'rainbow-delimiters-mode-enable))

(require 'sly-autoloads)

(with-eval-after-load 'sly
  (setopt inferior-lisp-program "sbcl")
  (setopt sly-command-switch-to-existing-lisp 'always))

(with-eval-after-load 'lisp-mode
  (add-hook 'lisp-data-mode-hook #'(lambda () (view-mode -1))))

(autoload-if-found '(hyperspec-lookup) "hyperspec" nil t)

(with-eval-after-load 'lisp-mode
  (define-key lisp-mode-map (kbd "C-c h") #'hyperspec-lookup))

(autoload-if-found '(eros-mode) "eros" nil t)

(with-eval-after-load 'emacs-lisp
  (add-hook 'emacs-lisp-mode-hook #'eros-mode))

(autoload-if-found '(turn-on-eldoc-mode) "eldoc" nil t)

(with-eval-after-load 'elisp-mode
  (add-hook 'emacs-lisp-mode-hook #'turn-on-eldoc-mode)
  (add-hook 'lisp-interaction-mode-hook #'turn-on-eldoc-mode))

(with-eval-after-load 'ielm
  (add-hook 'ielm-mode-hook #'turn-on-eldoc-mode))

(autoload-if-found '(elsa-run) "elsa" nil t)

(autoload-if-found '(lispxmp) "lispxmp" nil t)

(autoload-if-found '(macrostep-expand macrostep-mode) "macrostep" nil t)

(with-eval-after-load 'elisp-mode
  (define-key emacs-lisp-mode-map (kbd "C-c e") #'macrostep-expand))

(autoload-if-found '(elisp-slime-nav-mode) "elisp-slime-nav" nil t)

(with-eval-after-load 'elisp-mode
  (add-hook 'emacs-lisp-mode-hook #'elisp-slime-nav-mode))

(with-eval-after-load 'ielm
  (add-hook 'ielm-mode-hook #'elisp-slime-nav-mode))

(autoload-if-found '(nameless-mode) "nameless" nil t)

(with-eval-after-load 'elisp-mode
  (add-hook 'emacs-lisp-mode-hook #'nameless-mode))

(with-eval-after-load 'ielm
  (add-hook 'ielm-mode-hook #'nameless-mode))

(autoload-if-found '(elisp-refs-function
                     elisp-refs-macro
                     elisp-refs-variable
                     elisp-refs-special
                     elisp-refs-symbol) "elisp-refs" nil t)

(autoload-if-found '(highlight-quoted-mode) "highlight-quoted" nil t)

(with-eval-after-load 'elisp-mode
  (add-hook 'emacs-lisp-mode-hook #'highlight-quoted-mode))

(autoload-if-found '(highlight-defined-mode) "highlight-defined" nil t)

(with-eval-after-load 'elisp-mode
  (add-hook 'emacs-lisp-mode-hook #'highlight-defined-mode))

(defun my/ielm-history ()
  (interactive)
  (insert
   (completing-read
    "choice history: "
    (progn
      (let ((history nil)
            (comint-input-ring nil))
        (dotimes (index (ring-length comint-input-ring))
          (push (ring-ref comint-input-ring index) history))
        history)))))

(autoload-if-found '(anakondo-minor-mode) "anakondo" nil t)

(autoload-if-found '(cider cider-format-buffer cider-switch-to-last-clojure-buffer) "cider" nil t)
(autoload-if-found '(cider-doc) "cider-doc" nil t)


(with-eval-after-load 'cider-common
  (setopt cider-special-mode-truncate-lines nil))

(with-eval-after-load 'cider-mode
  (setopt cider-font-lock-reader-conditionals nil)
  (setopt cider-font-lock-dynamically '(macro core function var)))

(with-eval-after-load 'cider-repl
  (setopt cider-repl-buffer-size-limit 1000000)
  (setopt cider-repl-wrap-history t)
  (setopt cider-repl-history-size 10000)
  (setopt cider-repl-tab-command #'indent-for-tab-command)
  (setopt cider-repl-display-in-current-window t))

(with-eval-after-load 'nrepl-client
  (setopt nrepl-use-ssh-fallback-for-remote-hosts t)
  (setopt nrepl-hide-special-buffers t))

(with-eval-after-load 'cider-eval
  (setopt cider-show-error-buffer nil)
  (setopt cider-auto-select-error-buffer nil))

(with-eval-after-load 'clojure-mode
  (define-key clojure-mode-map (kbd "C-c h") #'cider-doc))

(autoload-if-found '(kibit kibit-current-file kibit-accept-proposed-change) "kibit-helper" nil t)

(autoload-if-found '(inf-clojure) "inf-clojure" nil t)

(autoload-if-found '(clang-format-buffer) "clang-format" nil t)

(autoload-if-found '(rainbow-csv-mode) "rainbow-csv" nil t)

(with-eval-after-load 'csv-mode
  (add-hook 'csv-mode-hook #'rainbow-csv-mode))

(autoload-if-found '(nodejs-repl
                     nodejs-repl-send-last-expression
                     nodejs-repl-send-line
                     nodejs-repl-send-region
                     nodejs-repl-send-buffer
                     nodejs-repl-load-file
                     nodejs-repl-switch-to-repl) "nodejs-repl" nil t)

(with-eval-after-load 'js2-mode
  (define-key js2-mode-map (kbd "C-x C-e") #'nodejs-repl-send-last-expression)
  (define-key js2-mode-map (kbd "C-c C-j") #'nodejs-repl-send-line)
  (define-key js2-mode-map (kbd "C-c C-r") #'nodejs-repl-send-region)
  (define-key js2-mode-map (kbd "C-c C-c") #'nodejs-repl-send-buffer)
  (define-key js2-mode-map (kbd "C-c C-l") #'nodejs-repl-load-file)
  (define-key js2-mode-map (kbd "C-c C-z") #'nodejs-repl-switch-to-repl))

(autoload-if-found '(js2-refactor-mode) "js2-refactor" nil t)

(with-eval-after-load 'js2-refactor
  (setopt js2r-use-strict t))

(with-eval-after-load 'js2-mode
  (add-hook 'js2-mode-hook #'js2-refactor-mode))

(with-eval-after-load 'typescript-mode
  (add-hook 'typescript-mode-hook #'js2-refactor-mode))

(autoload-if-found '(jest
                     jest-file
                     jest-file-dwim
                     jest-function
                     jest-last-failed
                     jest-repeat
                     jest-minor-mode) "jest" nil t)

(with-eval-after-load 'typescript-mode
  (add-hook 'typescript-mode-hook #'jest-minor-mode))

(autoload-if-found '(robe-mode inf-ruby-console-auto) "robe" nil t)

(autoload-if-found '(rubocop-mode) "rubocop" nil t)

(with-eval-after-load 'ruby-mode
  (setopt rubocop-keymap-prefix "C-c C-x")

  (add-hook 'ruby-mode-hook #'rubocop-mode))

(autoload-if-found '(ruby-refactor-mode-launch) "ruby-refactor" nil t)

(with-eval-after-load 'ruby-mode
  (add-hook 'ruby-mode-hook #'ruby-refactor-mode-launch))

(autoload-if-found '(inf-ruby inf-ruby-minor-mode) "inf-ruby" nil t)

(defun my/irb-history ()
  (interactive)
  (when (and (fboundp '-distinct)
             (fboundp 's-lines)
             (fboundp 'f-read-text))
    (insert
     (completing-read
      "choose history: "
      (mapcar #'list (-distinct (s-lines (f-read-text "~/.irb_history"))))))))

(with-eval-after-load 'ruby-mode
  (add-hook 'ruby-mode-hook #'inf-ruby-minor-mode))

(autoload-if-found '(yard-mode) "yard-mode" nil t)

(with-eval-after-load 'ruby-mode
  (add-hook 'ruby-mode-hook #'yard-mode))

(autoload-if-found '(sqlind-setup sqlind-minor-mode) "sql-indent" nil t)

(with-eval-after-load 'sql
  (add-hook 'sql-mode-hook #'sqlind-setup)
  (add-hook 'sql-mode-hook #'sqlind-minor-mode))

(autoload-if-found '(composer-get-config
                     composer-get-bin-dir
                     composer-install
                     composer-dump-autoload
                     composer-require
                     composer-update
                     composer-find-json-file
                     composer-view-lock-file
                     composer-run-vendor-bin-command
                     composer-run-script
                     composer-setup-managed-phar
                     composer) "composer" nil t)

(autoload-if-found '(php-runtime-expr php-runtime-eval) "php-runtime" nil t)

(autoload-if-found '(psysh psysh-doc) "psysh" nil t)

(with-eval-after-load 'php-mode
  (define-key php-mode-map (kbd "C-c h") #'psysh-doc))

(autoload-if-found '(php-doc-block) "php-doc-block" nil t)

(autoload-if-found '(phpstan-analyze-this-file
                     phpstan-analyze-file
                     phpstan-analyze-project
                     phpstan-generate-baseline
                     phpstan-find-baseline-file
                     phpstan-pro
                     phpstan-insert-ignore
                     phpstan-copy-dumped-type
                     phpstan-insert-dumptype) "phpstan" nil t)

(with-eval-after-load 'phpstan
  (setopt phpstan-memory-limit "4G")
  (setopt phpstan-activate-editor-mode t))

(autoload-if-found '(phpunit-current-test
                     phpunit-current-class
                     phpunit-current-project
                     phpunit-group) "phpunit" nil t)

(with-eval-after-load 'php-mode
  (keymap-set php-mode-map "C-c ;" #'phpunit-current-test)
  (keymap-set php-mode-map "C-c C-;" #'phpunit-current-test))

(autoload-if-found '(poly-markdown-mode) "poly-markdown" nil t)

(autoload-if-found '(doclive-preview-buffer
                     doclive-preview-file
                     doclive-stop-server
                     doclive-reload-page) "doclive" nil t)

(with-eval-after-load 'markdown-mode
  (keymap-set markdown-mode-map "C-c M-v" #'doclive-preview-buffer))

(with-eval-after-load 'org
  (keymap-set org-mode-map "C-c M-v" #'doclive-preview-buffer))

(autoload-if-found '(fish-repl) "fish-repl" nil t)

(autoload-if-found '(emmet-mode) "emmet-mode" nil t)

(with-eval-after-load 'html-mode
  (add-hook 'html-mode-hook #'emmet-mode))

(with-eval-after-load 'css-mode
  (add-hook 'css-mode-hook #'emmet-mode))

(with-eval-after-load 'nxml-mode
  (add-hook 'nxml-mode-hook #'emmet-mode))

(with-eval-after-load 'web-php-blade-mode
  (add-hook 'web-php-blade-mode #'emmet-mode))

(with-eval-after-load 'emmet-mode
  (define-key emmet-mode-keymap (kbd "C-j") nil)
  (define-key emmet-mode-keymap (kbd "M-j") #'emmet-expand-line)

  (setopt emmet-self-closing-tag-style "")
  (setopt emmet-indent-after-insert nil))

(autoload-if-found '(jq-interactively) "jq-mode" nil t)

(with-eval-after-load 'json-mode
  (define-key json-mode-map (kbd "C-c C-j") #'jq-interactively))

(autoload-if-found '(json-reformat-region) "json-reformat" nil t)

(autoload-if-found '(dasel-interactive) "dasel-interactive" nil t)
(autoload-if-found '(dasel-convert) "dasel-convert" nil t)
(autoload-if-found '(dasel-format-buffer dasel-format-region) "dasel-format" nil t)
(autoload-if-found '(dasel-edit-put) "dasel-edit" nil t)

(autoload-if-found '(consult-dasel) "consult-dasel" nil t)

(autoload-if-found '(py-isort-region
                     py-isort-buffer
                     py-isort-before-save) "py-isort" nil t)

(autoload-if-found '(flutter-test-mode
                     flutter-run
                     flutter-run-device
                     flutter-run-or-hot-reload
                     flutter-test-all
                     flutter-test-current-file
                     flutter-test-at-point
                     flutter-mode) "flutter" nil t)

(with-eval-after-load 'flutter
  (add-hook 'flutter-mode-hook
            #'(lambda ()
                (push '("*Flutter*") popwin:special-display-config)
                (flutter--initialize))))

(defun my/flutter-switch-buffer ()
  (interactive)
  (when (get-buffer "*Flutter*")
    (pop-to-buffer "*Flutter*")))

(with-eval-after-load 'dart-mode
  (define-key dart-mode-map (kbd "C-c z") #'my/flutter-switch-buffer))

(autoload-if-found '(go-test-current-file
                     go-test-current-test
                     go-test-current-project
                     go-test-current-benchmark
                     go-run) "gotest" nil t)

(with-eval-after-load 'go-mode
  (keymap-set go-mode-map "C-x ! f" #'go-test-current-file)
  (keymap-set go-mode-map "C-x ! t" #'go-test-current-test)
  (keymap-set go-mode-map "C-x ! p" #'go-test-current-project)
  (keymap-set go-mode-map "C-x ! b" #'go-test-current-benchmark)
  (keymap-set go-mode-map "C-x ! x" #'go-run))

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

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

  (add-hook 'org-mode-hook #'view-mode)

  (setopt org-tags-match-list-sublevels nil)

  (setq org-directory (my/ghq-repo-path "github.com/takeokunn-private/private"))

  (setq org-todo-keywords '((sequence "TODO(t)" "SOMEDAY(s)" "WAIT(w)" "REVIEW(r)" "QA(q)" "|" "DONE(d)")))

  (setq org-startup-folded 'fold)
  (setq org-startup-truncated nil)

  (defvar my/org-agenda-files `(,(concat org-directory "/task")
                                ,(concat org-directory "/archive/2023")
                                ,(concat org-directory "/archive/2024")
                                ,(concat org-directory "/archive/2025")
                                ,(concat org-directory "/archive/2026")))

  (setq org-agenda-files my/org-agenda-files)
  (setq org-archive-location `,(format (expand-file-name "archive/%s/%s.org::* Archived Tasks" org-directory)
                                       (format-time-string "%Y" (current-time))
                                       (format-time-string "%Y-%m-%d" (current-time))))
  (setq org-extend-today-until 4)
  (setq org-use-effective-time t)

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

  (defun my/update-org-agenda-files ()
    (interactive)
    (setq org-agenda-files my/org-agenda-files)))

(with-eval-after-load 'org-src
  (setopt org-src-window-setup 'current-window)
  (setopt org-src-fontify-natively nil)
  (setopt org-src-tab-acts-natively nil)

  (add-hook 'org-src-mode-hook
            #'(lambda ()
                (setq-local indent-tabs-mode nil)
                (view-mode -1))))

(autoload-if-found '(org-clock-load) "org-clock" nil t)

(with-eval-after-load 'org
  (add-hook 'org-mode-hook #'org-clock-load))

(with-eval-after-load 'org-clock
  (setq org-clock-out-remove-zero-time-clocks t)
  (setq org-clock-clocked-in-display 'mode-line))

(with-eval-after-load 'org-list
  (setq org-list-allow-alphabetical t))

(with-eval-after-load 'org-keys
  (setq org-use-extra-keys t)
  (setq org-use-speed-commands t)

  (add-to-list 'org-speed-commands '("d" org-todo "DONE"))
  (add-to-list 'org-speed-commands '("j" call-interactively #'consult-org-heading))
  (add-to-list 'org-speed-commands '("$" call-interactively #'org-archive-subtree)))

(autoload-if-found '(org-capture) "org-capture" nil t)

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

(with-eval-after-load 'org-capture
  (advice-add 'org-capture
              :before #'(lambda (&rest _)
                          (remove-hook 'org-mode-hook #'view-mode)
                          (remove-hook 'prog-mode-hook #'view-mode)))
  (advice-add 'org-capture
              :after #'(lambda (&rest _)
                         (add-hook 'org-mode-hook #'view-mode)
                         (add-hook 'prog-mode-hook #'view-mode)))

  (setq org-capture-use-agenda-date t)
  (setq org-capture-bookmark nil)
  (setq org-capture-templates `(("m" "Memo" entry (file ,(expand-file-name "memo.org" org-directory))
                                 "* %T\n%?")
                                ("j" "Journal" entry (file+olp+datetree ,(expand-file-name "journal.org" org-directory))
                                 "* %U\n%?\n%i\n")
                                ("1" "Work" entry (file+headline ,(expand-file-name "task/work.org" org-directory) "Backlog")
                                 "** TODO Capture %U\n%?")
                                ("2" "Other" entry (file+headline ,(expand-file-name "task/other.org" org-directory) "Backlog")
                                 "** TODO Capture %U\n%?"))))

(with-eval-after-load 'org-duration
  (setq org-duration-format (quote h:mm)))

(autoload-if-found '(org-id-store-link) "org-id" nil t)

(with-eval-after-load 'org-id
  (setq org-id-locations-file (expand-file-name ".org-id-locations" org-directory))
  (setq org-id-extra-files (append org-agenda-text-search-extra-files)))

(autoload-if-found '(org-encrypt-entry
                     org-encrypt-entries
                     org-decrypt-entry
                     org-decrypt-entries) "org-crypt" nil t)

(with-eval-after-load 'org
  (setopt org-tags-exclude-from-inheritance '("crypt")))

(with-eval-after-load 'org-crypt
  (setopt org-crypt-key "0B10DAA7BA0236D7382287660F79C0AB03FD7A1C"))

(autoload-if-found '(orgtbl-mode org-table-begin org-table-end) "org-table" nil t)

(with-eval-after-load 'org-table
  (defun my/org-table-align-markdown ()
    "Replace \"+\" sign with \"|\" in org-table."
    (when (member major-mode '(markdown-mode))
      (save-excursion
        (save-restriction
          (narrow-to-region (org-table-begin) (org-table-end))
          (goto-char (point-min))
          (while (search-forward "-+-" nil t)
            (replace-match "-|-"))))))

  (advice-add 'org-table-align :before #'my/org-table-align-markdown))

(with-eval-after-load 'org-journal
  (setq org-journal-dir (expand-file-name "journal" org-directory))
  (setq org-journal-start-on-weekday 7)
  (setq org-journal-prefix-key "C-c j"))

(autoload-if-found '(org-generate) "org-generate" nil t)

(autoload-if-found '(org-pomodoro) "org-pomodoro" nil t)

(autoload-if-found '(org-view-mode) "org-view-mode" nil t)

(autoload-if-found '(org-random-todo org-random-todo-goto-current) "org-random-todo" nil t)

(autoload-if-found '(org-dashboard-display) "org-dashboard" nil t)

(autoload-if-found '(org-volume-update-entry-from-dblock) "org-volume" nil t)

(autoload-if-found '(org-sliced-images-mode) "org-sliced-images" nil t)

(with-eval-after-load 'org
  (add-hook 'org-mode-hook #'org-sliced-images-mode))

(autoload-if-found '(org-ql-query org-ql-select) "org-ql" nil t)

(autoload-if-found '(org-preview-html-mode
                     org-preview-html-refresh
                     org-preview-html-pop-window-to-frame) "org-preview-html" nil t)

(with-eval-after-load 'org-preview-html
  (setopt org-preview-html-viewer 'xwidget))

(with-eval-after-load 'org-faces
  (setq org-link '(t (:foreground "#ebe087" :underline t))))

(autoload-if-found '(org-superstar-mode) "org-superstar")

(with-eval-after-load 'org
  (add-hook 'org-mode-hook #'org-superstar-mode))

(with-eval-after-load 'org-superstar
  (setopt org-superstar-headline-bullets-list '("◉" "○" "✸" "✿"))
  (setopt org-superstar-leading-bullet " "))

(autoload-if-found '(toc-org-mode) "toc-org" nil t)

(with-eval-after-load 'org
  (add-hook 'org-mode-hook #'toc-org-mode))

(autoload-if-found '(org-tree-slide-mode org-tree-slide-skip-done-toggle) "org-tree-slide" nil t)

(with-eval-after-load 'org-tree-slide
  (setopt org-tree-slide-skip-outline-level 4))

(autoload-if-found '(org-store-link) "ol" nil t)

(with-eval-after-load 'ol
  (setq org-link-file-path-type 'relative))

(autoload-if-found '(orgit-store-link

                     orgit-status-store
                     orgit-status-open
                     orgit-status-export
                     orgit-status-complete-link

                     orgit-log-store
                     orgit-log-open
                     orgit-log-export
                     orgit-log-complete-link

                     orgit-rev-store
                     orgit-rev-open
                     orgit-rev-export
                     orgit-rev-complete-link) "orgit" nil t)

(with-eval-after-load 'org
  (org-link-set-parameters "orgit"
                           :store    #'orgit-status-store
                           :follow   #'orgit-status-open
                           :export   #'orgit-status-export
                           :complete #'orgit-status-complete-link)

  (org-link-set-parameters "orgit-log"
                           :store    #'orgit-log-store
                           :follow   #'orgit-log-open
                           :export   #'orgit-log-export
                           :complete #'orgit-log-complete-link)

  (org-link-set-parameters "orgit-rev"
                           :store    #'orgit-rev-store
                           :follow   #'orgit-rev-open
                           :export   #'orgit-rev-export
                           :complete #'orgit-rev-complete-link))

(with-eval-after-load 'magit
  (keymap-set magit-mode-map "<remap> <org-store-link>" #'orgit-store-link))

(autoload-if-found '(org-agenda) "org-agenda" nil t)

(with-eval-after-load 'org-agenda
  (setq org-agenda-span 'day)
  (setq org-agenda-start-on-weekday 1)
  (setq org-agenda-todo-ignore-with-date t)
  (setq org-agenda-todo-list-sublevels nil)

  (advice-add 'org-archive-subtree :around #'my/advice-disable-buffer-readonly))

(autoload-if-found '(org-super-agenda-mode) "org-super-agenda" nil t)

(add-hook 'after-init-hook #'org-super-agenda-mode)

(with-eval-after-load 'org-agenda
  (setopt org-agenda-custom-commands
          '(("z" "Super Agenda"
             ((agenda "" ((org-agenda-span 'day)
                          (org-super-agenda-groups
                           '((:name "Today"
                                    :time-grid t
                                    :date today
                                    :todo "TODAY"
                                    :scheduled today
                                    :order 1)))))
              (alltodo "" ((org-agenda-overriding-header "")
                           (org-super-agenda-groups
                            '((:name "Next to do"
                                     :todo "NEXT"
                                     :order 1)
                              (:name "Important"
                                     :tag "Important"
                                     :priority "A"
                                     :order 6)
                              (:name "Due Today"
                                     :deadline today
                                     :order 2)
                              (:name "Due Soon"
                                     :deadline future
                                     :order 8)
                              (:name "Overdue"
                                     :deadline past
                                     :order 7)
                              (:name "Assignments"
                                     :tag "Assignment"
                                     :order 10)
                              (:name "Issues"
                                     :tag "Issue"
                                     :order 12)
                              (:name "Projects"
                                     :tag "Project"
                                     :order 14)
                              (:name "Emacs"
                                     :tag "Emacs"
                                     :order 13)
                              (:name "Research"
                                     :tag "Research"
                                     :order 15)
                              (:name "To read"
                                     :tag "Read"
                                     :order 30)
                              (:name "Waiting"
                                     :todo "WAITING"
                                     :order 20)
                              (:name "trivial"
                                     :priority<= "C"
                                     :tag ("Trivial" "Unimportant")
                                     :todo ("SOMEDAY" )
                                     :order 90)
                              (:discard (:tag ("Chore" "Routine" "Daily"))))))))))))

(autoload-if-found '(org-hyperscheduler-open) "org-hyperscheduler" nil t)

(autoload-if-found '(org-redmine-get-issue) "org-redmine" nil t)

(with-eval-after-load 'org-redmine
  (setopt org-redmine-template-header "[#%i%] %s%")
  (setopt org-redmine-template-property '(("project_name" . "%p_n%"))))

(autoload-if-found '(org-ai-mode) "org-ai" nil t)

(with-eval-after-load 'org
  (add-to-list 'org-structure-template-alist '("A" . "ai"))

  (add-hook 'org-mode-hook #'org-ai-mode))

(with-eval-after-load 'org-ai
  (setopt org-ai-default-chat-model "gpt-3.5-turbo"))

(autoload-if-found '(org-babel-do-load-languages) "org" nil t)

(with-eval-after-load 'org
  (add-hook 'org-mode-hook
            #'(lambda ()
                (org-babel-do-load-languages 'org-babel-load-languages
                                             '((awk . t)
                                               (C . t)
                                               (R . t)
                                               (clojure . t)
                                               (emacs-lisp . t)
                                               (haskell . t)
                                               (java . t)
                                               (js . t)
                                               (lisp . t)
                                               (makefile . t)
                                               (perl . t)
                                               (plantuml . t)
                                               (python . t)
                                               (ruby . t)
                                               (scheme . t)
                                               (shell . t)
                                               (sql . t)
                                               (shell . t))))))

(with-eval-after-load 'ob-core
  (setq org-confirm-babel-evaluate nil)
  (setq org-babel-default-header-args '((:session . "none")
                                        (:results . "drawer replace")
                                        (:exports . "code")
                                        (:cache . "no")
                                        (:noweb . "no")
                                        (:hlines . "no")
                                        (:tangle . "no"))))

(with-eval-after-load 'ob-eval
  (advice-add #'org-babel-eval-error-notify
              :around #'(lambda (old-func &rest args)
                          (when (not (string= (nth 1 args)
                                              "mysql: [Warning] Using a password on the command line interface can be insecure.\n"))
                            (apply old-func args)))))

(with-eval-after-load 'ob-tangle
  (advice-add 'org-babel-tangle :around #'my/advice-disable-buffer-readonly))

(autoload-if-found '(ob-async-org-babel-execute-src-block) "ob-async" nil t)

(autoload-if-found '(org-babel-execute:fish) "ob-fish" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("fish" . fish)))

(autoload-if-found '(org-babel-execute:rust) "ob-rust" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("rust" . rust)))

(autoload-if-found '(org-babel-execute:go) "ob-go" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("go" . go)))

(autoload-if-found '(ob-translate:google-translate) "ob-translate" nil t)

(with-eval-after-load 'text-mode
  (define-derived-mode translate-mode text-mode "translate"))

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("translate" . translate)))

(autoload-if-found '(org-babel-execute:typescript) "ob-typescript" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("typescript" . typescript)))

(autoload-if-found '(org-babel-execute:php) "ob-php" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("php" . php)))

(autoload-if-found '(org-babel-execute:phpstan) "ob-phpstan" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("phpstan" . phpstan)))

(autoload-if-found '(org-babel-execute:http) "ob-http" nil t)
(autoload-if-found '(ob-http-mode) "ob-http-mode" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("http" . ob-http)))

(autoload-if-found '(org-babel-execute:mermaid) "ob-mermaid" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("mermaid" . mermaid)))

(autoload-if-found '(org-babel-execute:graphql) "ob-graphql" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("graphql" . graphql)))

(autoload-if-found '(org-babel-execute:rust) "ob-rust" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("rust" . rust)))

(autoload-if-found '(org-babel-execute:swift) "ob-swift" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("swift" . swift)))

(autoload-if-found '(org-babel-execute:elixir) "ob-elixir" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("elixir" . elixir)))

(autoload-if-found '(org-babel-execute:dart) "ob-dart" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("dart" . dart)))

(autoload-if-found '(org-babel-execute:fsharp) "ob-fsharp" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("fsharp" . fsharp)))

(autoload-if-found '(org-babel-execute:treesitter) "ob-treesitter" nil t)

(with-eval-after-load 'prog-mode
  (define-derived-mode treesitter-mode prog-mode "treesitter"))

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("treesitter" . treesitter)))

(autoload-if-found '(org-babel-execute:base64) "ob-base64" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("base64" . base64)))

(with-eval-after-load 'ob-lisp
  (defalias 'org-babel-execute:common-lisp 'org-babel-execute:lisp))

(autoload-if-found '(org-babel-execute:racket) "ob-racket" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("racket" . racket)))

(autoload-if-found '(org-babel-execute:prolog) "ob-prolog" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("prolog" . pl)))

(autoload-if-found '(org-babel-execute:deno) "ob-deno" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("deno" . deno)))

(autoload-if-found '(org-babel-execute:gleam) "ob-gleam" nil t)

(with-eval-after-load 'org-src
  (add-to-list 'org-src-lang-modes '("gleam" . gleam)))

(autoload-if-found '(org-nix-shell-mode) "org-nix-shell" nil t)

(with-eval-after-load 'org
  (add-hook 'org-mode-hook #'org-nix-shell-mode))

(autoload-if-found '(org-export-define-backend) "ox" nil t)

(with-eval-after-load 'ox-html
  (setopt org-html-head-include-default-style nil)
  (setopt org-html-head-include-scripts nil)
  (setopt org-html-doctype "html5")
  (setopt org-html-coding-system 'utf-8-unix))

(autoload-if-found '(org-gfm-export-as-markdown
                     org-gfm-convert-region-to-md
                     org-gfm-export-to-markdown
                     org-gfm-publish-to-gfm) "ox-gfm" nil t)

(autoload-if-found '(org-zenn-export-as-markdown
                     org-zenn-export-to-markdown
                     org-zenn-publish-to-markdown
                     org-zenn-convert-region-to-md) "ox-zenn" nil t)

(autoload-if-found '(org-hatena-export-as-hatena
                     org-hatena-export-to-hatena
                     org-hatena-export-to-hatena-and-open) "ox-hatena" nil t)

(autoload-if-found '(org-qmd-export-as-markdown
                     org-qmd-convert-region-to-md
                     org-qmd-export-to-markdown) "ox-qmd" nil t)

(autoload-if-found '(org-hugo-export-as-md
                     org-hugo-export-to-md
                     org-hugo-export-wim-to-md
                     org-hugo-debug-info) "ox-hugo" nil t)

(with-eval-after-load 'ox-hugo
  (setopt org-hugo-auto-set-lastmod t))

(autoload-if-found '(org-typst-export-block
                     org-typst-headline
                     org-typst-item
                     org-typst-keyword
                     org-typst-section
                     org-typst-src-block
                     org-typst-export-as-typst
                     org-typst-export-to-typst
                     org-typst-export-to-pdf
                     org-typst-compile) "ox-typst" nil t)

(org-export-define-backend 'typst-slide
  '((export-block . org-typst-export-block)
    (headline . org-typst-headline)
    (item . org-typst-item)
    (keyword . org-typst-keyword)
    (section . org-typst-section)
    (src-block . org-typst-src-block))
  :menu-entry
  '(?y "Export to Typst"
       ((?F "As Typst buffer" org-typst-export-as-typst)
        (?f "As Typst file" org-typst-export-to-typst)
        (?p "As PDF file" org-typst-export-to-pdf)))
  :options-alist
  '((:typst-format-drawer-function nil nil #'(lambda (_ contents) contents))
    (:typst-format-inlinetask-function nil
                                       nil
                                       #'(lambda (_ contents) contents))))

(defun org-typst-slide-export-as-typst
    (&optional async subtreep visible-only body-only ext-plist)
  (interactive)
  (org-export-to-buffer 'typst-slide "*Org Typst Slide Export*"
    async subtreep visible-only body-only ext-plist))

(defun org-typst-slide-export-to-typst
    (&optional async subtreep visible-only body-only ext-plist)
  (interactive)
  (let ((outfile (org-export-output-file-name ".typ" subtreep)))
    (org-export-to-file 'typst-slide outfile
      async subtreep visible-only body-only ext-plist)))

(autoload-if-found '(org-roam-graph) "org-roam" nil t)

(keymap-global-set "C-c n g" #'org-roam-graph)
(keymap-global-set "C-c n l" #'org-roam-buffer-toggle)
(keymap-global-set "C-c n f" #'org-roam-node-find)
(keymap-global-set "C-c n i" #'org-roam-node-insert)
(keymap-global-set "C-c n c" #'org-roam-capture)
(keymap-global-set "C-c n d" #'org-roam-dailies-map)
(keymap-global-set "C-c n j" #'org-roam-dailies-goto-today)

(with-eval-after-load 'org-roam
  (setopt org-roam-directory `,(my/ghq-repo-path "github.com/takeokunn/blog")))

(autoload-if-found '(org-roam-buffer-toggle) "org-roam-mode" nil t)

(autoload-if-found '(org-roam-node-find org-roam-node-insert) "org-roam-node" nil t)

(with-eval-after-load 'org-roam-node
  (setopt org-roam-completion-everywhere nil))

  (autoload-if-found '(org-roam-db-autosync-enable) "org-roam-db" nil t)

  (defun my/org-roam-db-autosync-maybe-enable ()
    "Enable Org-roam autosync only when its backing repository is checked out.
`org-roam-directory' resolves through `my/ghq-repo-path', which falls back to
a path that may not exist when the repository has never been cloned; syncing
against a missing directory signals file-missing on every Org buffer visit."
    (when (file-directory-p (my/ghq-repo-path "github.com/takeokunn/blog"))
      (org-roam-db-autosync-enable)))

  (with-eval-after-load 'org
    (add-hook 'org-mode-hook #'my/org-roam-db-autosync-maybe-enable))

  (with-eval-after-load 'org-roam-db
    (setq org-roam-db-gc-threshold (* 4 gc-cons-threshold)))

(autoload-if-found '(org-roam-capture) "org-roam-capture" nil t)

(with-eval-after-load 'org-roam-capture
  (setopt org-roam-capture-templates '(("f" "Fleeting(一時メモ)" plain "%?"
                                        :target (file+head "hugo/org/fleeting/%<%Y%m%d%H%M%S>-${slug}.org" "#+TITLE: ${title}\n")
                                        :unnarrowed t)
                                       ("l" "Literature(文献)" plain "%?"
                                        :target (file+head "hugo/org/literature/%<%Y%m%d%H%M%S>-${slug}.org" "#+TITLE: ${title}\n")
                                        :unnarrowed t)
                                       ("p" "Permanent(記事)" plain "%?"
                                        :target (file+head "hugo/org/permanent/%<%Y%m%d%H%M%S>-${slug}.org" "#+TITLE: ${title}\n")
                                        :unnarrowed t)
                                       ("d" "Diary(日記)" plain "%?"
                                        :target (file+head "hugo/org/diary/%<%Y%m%d%H%M%S>-${slug}.org" "#+TITLE: ${title}\n")
                                        :unnarrowed t)
                                       ("z" "Zenn" plain "%?"
                                        :target (file+head "zenn/org/articles/%<%Y%m%d%H%M%S>.org" "#+TITLE: ${title}\n")
                                        :unnarrowed t)
                                       ("t" "dev.to" plain "%?"
                                        :target (file+head "devto/articles/%<%Y%m%d%H%M%S>.org" "#+TITLE: ${title}\n")
                                        :unnarrowed t)
                                       ("m" "Private" plain "%?"
                                        :target (file+head "hugo/org/private/%<%Y%m%d%H%M%S>.org.gpg" "#+TITLE: ${title}\n")
                                        :unnarrowed t)
                                       ("o" "Poem" plain "%?"
                                        :target (file+head "hugo/org/poem/%<%Y%m%d%H%M%S>-${slug}.org" "#+TITLE: ${title}\n")
                                        :unnarrowed t))))

(autoload-if-found '(org-roam-dailies-map
                     org-roam-dailies-goto-today
                     org-roam-dailies-goto-yesterday
                     org-roam-dailies-goto-tomorrow
                     org-roam-dailies-capture-today
                     org-roam-dailies-goto-next-note
                     org-roam-dailies-goto-previous-note
                     org-roam-dailies-goto-date
                     org-roam-dailies-capture-date
                     org-roam-dailies-find-directory) "org-roam-dailies" nil t)

(with-eval-after-load 'org-roam-dailies
  (setopt org-roam-dailies-directory "org/daily/")

  (define-key org-roam-dailies-map (kbd "d") #'org-roam-dailies-goto-today)
  (define-key org-roam-dailies-map (kbd "y") #'org-roam-dailies-goto-yesterday)
  (define-key org-roam-dailies-map (kbd "t") #'org-roam-dailies-goto-tomorrow)
  (define-key org-roam-dailies-map (kbd "n") #'org-roam-dailies-capture-today)
  (define-key org-roam-dailies-map (kbd "f") #'org-roam-dailies-goto-next-note)
  (define-key org-roam-dailies-map (kbd "b") #'org-roam-dailies-goto-previous-note)
  (define-key org-roam-dailies-map (kbd "c") #'org-roam-dailies-goto-date)
  (define-key org-roam-dailies-map (kbd "v") #'org-roam-dailies-capture-date)
  (define-key org-roam-dailies-map (kbd ".") #'org-roam-dailies-find-directory))

(autoload-if-found '(org-roam-export--org-html--reference) "org-roam-export" nil t)

(with-eval-after-load 'ox-html
  (advice-add 'org-html--reference :override #'org-roam-export--org-html--reference))

(autoload-if-found '(org-roam-graph org-roam-graph--open) "org-roam-graph" nil t)

(autoload-if-found '(org-roam-overlay-mode) "org-roam-overlay" nil t)

(with-eval-after-load 'org-roam-mode
  (add-hook 'org-roam-mode-hook #'org-roam-overlay-mode))

(autoload-if-found '(org-roam-protocol-open-ref org-roam-protocol-open-node) "org-roam-protocol" nil t)

(with-eval-after-load 'org-roam-protocol
  (add-to-list 'org-protocol-protocol-alist '("org-roam-ref" :protocol "roam-ref" :function org-roam-protocol-open-ref))
  (add-to-list 'org-protocol-protocol-alist '("org-roam-node" :protocol "roam-node" :function org-roam-protocol-open-node))

  (setopt org-roam-protocol-store-links t))

(autoload-if-found '(consult-org-roam-mode
                     consult-org-roam-file-find
                     consult-org-roam-backlinks
                     consult-org-roam-backlinks-recursive
                     consult-org-roam-forward-links
                     consult-org-roam-search) "consult-org-roam" nil t)

(keymap-global-set "C-c n f" #'consult-org-roam-file-find)
(keymap-global-set "C-c n b" #'consult-org-roam-backlinks)
(keymap-global-set "C-c n B" #'consult-org-roam-backlinks-recursive)
(keymap-global-set "C-c n l" #'consult-org-roam-forward-links)
(keymap-global-set "C-c n r" #'consult-org-roam-search)

(with-eval-after-load 'org
  (add-hook 'org-mode-hook #'consult-org-roam-mode))

(with-eval-after-load 'consult-org-roam
  (setq consult-org-roam-grep-func #'consult-ripgrep)
  (setq consult-org-roam-buffer-narrow-key ?r)
  (setq consult-org-roam-buffer-after-buffers nil))

;; consult-org-roam-buffer.el reads/sets org-roam-buffer-open-buffer-list
;; without ever declaring it, so exiting the minibuffer before its :items
;; function has run signals (void-variable org-roam-buffer-open-buffer-list).
(with-eval-after-load 'consult-org-roam-buffer
  (defvar org-roam-buffer-open-buffer-list nil))

(autoload-if-found '(org-roam-ui-mode) "org-roam-ui" nil t)

(with-eval-after-load 'org-roam-mode
  (add-hook 'org-roam-mode-hook #'org-roam-ui-mode))

(with-eval-after-load 'org-roam-ui
  (setopt org-roam-ui-sync-theme t)
  (setopt org-roam-ui-follow t)
  (setopt org-roam-ui-update-on-save t)
  (setopt org-roam-ui-open-on-start t))

(autoload-if-found '(org-roam-timestamps-mode) "org-roam-timestamps" nil t)

(with-eval-after-load 'org-roam-mode
  (add-hook 'org-roam-mode #'org-roam-timestamps-mode))

(with-eval-after-load 'org-roam-timestamps
  (setopt org-roam-timestamps-remember-timestamps nil))

(autoload-if-found '(org-roam-ql-nodes
                     org-roam-ql-search
                     org-roam-ql-defpred
                     org-roam-ql-agenda-buffer-from-roam-buffer
                     org-roam-ql-refresh-buffer
                     org-dblock-write:org-roam-ql) "org-roam-ql" nil t)

(autoload-if-found '(org-roam-ql-ql-init) "org-roam-ql-ql" nil t)

(add-hook 'after-init-hook #'org-roam-ql-ql-init)

(autoload-if-found '(citar-open
                     citar-open-entry
                     citar-open-files
                     citar-open-notes
                     citar-insert-citation
                     citar-insert-reference
                     citar-insert-bibtex) "citar" nil t)

(autoload-if-found '(citar-org-local-bib-files) "citar-org" nil t)

(keymap-global-set "C-c b o" #'citar-open)
(keymap-global-set "C-c b e" #'citar-open-entry)
(keymap-global-set "C-c b f" #'citar-open-files)
(keymap-global-set "C-c b n" #'citar-open-notes)
(keymap-global-set "C-c b i" #'citar-insert-citation)

(with-eval-after-load 'citar
  (setopt citar-bibliography
          `,(list (expand-file-name "hugo/references.bib" (my/ghq-repo-path "github.com/takeokunn/blog"))))

  (setopt org-cite-insert-processor 'citar)
  (setopt org-cite-follow-processor 'citar)
  (setopt org-cite-activate-processor 'citar))

(autoload-if-found '(citar-embark-mode) "citar-embark" nil t)

(with-eval-after-load 'citar
  (citar-embark-mode 1))

(autoload-if-found '(citar-org-roam-mode
                     citar-org-roam-cited
                     citar-org-roam-ref-add
                     citar-org-roam-open-current-refs) "citar-org-roam" nil t)

(with-eval-after-load 'citar
  (citar-org-roam-mode 1))

(with-eval-after-load 'citar-org-roam
  (setopt citar-org-roam-subdir "hugo/org/literature")
  (setopt citar-org-roam-note-title-template "${author} - ${title}"))