General Emacs Configuration

(setq remote-file-name-inhibit-locks t)

(defun turn-off-vc-for-remote-files ()
  "Disable version control for remote files.
Use with the `find-file-hook'."
  (when (file-remote-p (buffer-file-name))
    (setq-local vc-handled-backends nil)))

(add-hook 'find-file-hook 'turn-off-vc-for-remote-files)

(setq-default indent-tabs-mode nil)

(defun ha-cleanup-buffer-file ()
  "Cleanup a file, often done before a file save."
  (interactive)
  (ignore-errors
    (unless (or (equal major-mode 'makefile-mode)
                (equal major-mode 'makefile-bsdmake-mode))
      (untabify (point-min) (point-max)))
    (delete-trailing-whitespace)))

(add-hook 'before-save-hook #'ha-cleanup-buffer-file)

(use-package recentf
  :straight (:type built-in)
  :config
  (setq recentf-auto-cleanup 'never) ;; disable before we start recentf!
  (recentf-mode 1))

(setq backup-directory-alist `(("." . ,(concat user-emacs-directory "backups"))))

alias ls="ls --color=auto --hide='*~'"

(setq create-lockfiles nil   ; Having .# files around ain't helpful
      auto-save-default t
      delete-old-versions t
      kept-new-versions 6
      kept-old-versions 2
      version-control t)

(defun save-all-buffers ()
  "Save all buffers, because, why not?"
  (interactive)
  (save-some-buffers t))

;; See 'after-focus-change -hook?
(add-hook 'focus-out-hook 'save-all-buffers)

(defun url-download (url dest)
  "Download the file as URL and save in file, DEST.
Note that this doesn't do any error checking ATM."
  (interactive "sURL: \nDDestination: ")
  (let* ((url-parts (url-generic-parse-url url))
         (url-path  (url-filename url-parts))
         (filename  (file-name-nondirectory url-path))
         (target    (if (file-directory-p dest)
                        (file-name-concat dest filename)
                      dest))
         (callback (lambda (status destination)
                     (unwind-protect
                         (pcase status
                           (`(:error . ,_)
                            (message "Error downloading %s: %s" url (plist-get status :error)))
                           (_ (progn
                                ;; (switch-to-buffer (current-buffer))
                                (delete-region (point-min) (1+ url-http-end-of-headers))
                                (write-file destination)
                                (kill-buffer)
                                (when (called-interactively-p 'any)
                                  (kill-new destination)))))))))
    (message "Retrieving %s into %s" url target)
    (url-retrieve url callback (list target))))

(url-download "https://www.emacswiki.org/emacs/download/bookmark+.el"
              "~/Downloads/bookmark-plus.el")

(use-package vertico
  :config (vertico-mode))

(use-package vertico-directory
  :straight (el-patch :files ("~/.emacs.d/straight/repos/vertico/extensions/vertico-directory.el"))
  ;; More convenient directory navigation commands
  :bind (:map vertico-map
              ("RET" . vertico-directory-enter)
              ; ("DEL" . vertico-directory-delete-word)
              ("M-RET" . minibuffer-force-complete-and-exit)
              ("M-TAB" . minibuffer-complete))
  ;; Tidy shadowed file names
  :hook (rfn-eshadow-update-overlay . vertico-directory-tidy))

(use-package hotfuzz)

(use-package orderless
  :commands (orderless-filter)
  :custom
  (completion-ignore-case t)
  (completion-category-defaults nil)
  (completion-category-overrides '((file (styles partial-completion))))

  :init
  (defvar orderless-skip-highlighting nil
     "Not sure why this is being accessed.")

  (push 'orderless completion-styles))

(use-package fussy
  ;; :straight (:host github :repo "jojojames/fussy")
  :config
  (push 'fussy completion-styles)
  (setq completion-category-defaults nil
        completion-category-overrides nil
        fussy-filter-fn 'fussy-filter-orderless-flex
        fussy-score-fn 'fussy-hotfuzz-score))

(use-package savehist
  :init
  (savehist-mode))

;; Enable richer annotations using the Marginalia package
(use-package marginalia
  :init
  (setq marginalia-annotators-heavy t)
  :config
  (add-to-list 'marginalia-command-categories '(project-find-file . file))
  (marginalia-mode))

(global-set-key [remap dabbrev-expand] 'hippie-expand)
(global-set-key (kbd "M-<tab>") 'completion-at-point)

(setq hippie-expand-try-functions-list
      '(try-complete-file-name-partially   ; complete filenames, start with /
        try-complete-file-name
        yas-hippie-try-expand              ; expand matching snippets
        try-expand-all-abbrevs
        try-expand-list                    ; help when args repeated another's args
        try-expand-dabbrev
        try-expand-dabbrev-all-buffers
        try-expand-whole-kill              ; grab text from the kill ring
        try-expand-dabbrev-from-kill       ; as above
        try-complete-lisp-symbol-partially
        try-complete-lisp-symbol))

(defun hippie-expand-in-org (&rest ignored)
  "Calls `hippie-expand', limited to text buffers."
  (when (derived-mode-p 'text-mode)
    (call-interactively #'hippie-expand)))

(advice-add #'indent-for-tab-command :after #'hippie-expand-in-org)

(use-package cape
  :straight (:host github :repo "minad/cape")
  :init
  (setq completion-at-point-functions (list #'cape-emoji)))

(add-hook 'emacs-lisp-mode :after
          (lambda ()
            (setq-local completion-at-point-functions
                        (list #'cape-elisp-symbol))))

(use-package corfu
  :custom
  (corfu-cycle t)
  (corfu-separator ?\s)
  :init
  (global-corfu-mode))

(use-package yasnippet
  :config
  (add-to-list 'yas-snippet-dirs
               (expand-file-name "snippets" user-emacs-directory))
  (yas-global-mode +1))

(use-package yasnippet-snippets)

(use-package autoinsert
  :init
  (setq auto-insert-directory (expand-file-name "templates" user-emacs-directory))
  ;; Don't prompt before insertion:
  (setq auto-insert-query nil)

  (add-hook 'find-file-hook 'auto-insert)
  (auto-insert-mode t))

(defun ha-autoinsert-yas-expand()
  "Replace text in yasnippet template."
  (let ((auto-insert-query nil)
        (yas-indent-line nil))
    (yas-minor-mode +1)
    (when (fboundp 'evil-insert-state)
      (evil-insert-state))
    (yas-expand-snippet (buffer-string) (point-min) (point-max))))

(defun ha-auto-insert-file (filename-re snippet-name)
  "Autofill file buffer matching FILENAME-RE regular expression.
The contents inserted from the YAS SNIPPET-NAME."
  ;; The define-auto-insert takes a regular expression and an ACTION:
  ;; ACTION may also be a vector containing _successive_ single actions.
  ;; This means running this twice results in two repeated expansions, so:
  (unless (assoc filename-re auto-insert-alist 'equal)
    (define-auto-insert filename-re
      (vector snippet-name 'ha-autoinsert-yas-expand))))

(ha-auto-insert-file (rx "hamacs/" (one-or-more any) ".org" eol) "hamacs-config")
(ha-auto-insert-file (rx ".dir-locals.el") "dir-locals")

(use-package alert
  :init
  (setq alert-default-style
        (if (ha-running-on-macos?)
            'osx-notifier
          'libnotify)))

(use-package beep
  :straight nil   ; Already in the load-path
  :hook (after-init . (lambda () (beep-when-finished "Emacs has started." "Eemacs has started")))
  :config
  (dolist (func '(org-publish
                  org-publish-all
                  org-publish-project
                  compile
                  shell-command))
    (advice-add func :around #'beep-when-runs-too-long)))

(defvar ha-workspace-projects-personal nil "List of default projects with a name.")

(add-to-list 'ha-workspace-projects-personal
             '("projects" "~/projects" ("breathe.org" "tasks.org")))
(add-to-list 'ha-workspace-projects-personal
             '("personal" "~/personal" ("general.org")))
(add-to-list 'ha-workspace-projects-personal
             '("technical" "~/technical" ("ansible.org")))
(add-to-list 'ha-workspace-projects-personal
             '("hamacs" "~/src/hamacs" ("README.org" "ha-config.org")))

(defun ha-persp-exists? (name)
  "Return non-nill if a perspective of NAME exists."
  (when (fboundp 'perspectives-hash)
    (seq-contains (hash-table-keys (perspectives-hash)) name)))

(defun ha-workspace-initialize (&optional projects)
  "Precreate workspace projects from a PROJECTS list.
Each entry in the list is a list containing:
    - name (as a string)
    - project root directory
    - a optional list of files to display"
  (interactive)
  (unless projects
    (setq projects ha-workspace-projects-personal))

  (dolist (project projects)
    (seq-let (name root files) project
      (unless (ha-persp-exists? name)
        (message "Creating workspace: %s (from %s)" name root)
        (ha-project-persp root name files))))
  (persp-switch "main"))

(defun ha-project-persp (project &optional name files)
  "Create a new perspective, and then switch to the PROJECT.
If NAME is not given, then figure it out based on the name of the
PROJECT. If FILES aren't specified, then see if there is a
README. Otherwise, pull up Dired."
  (interactive (list (completing-read "Project: "
                                      (project-known-project-roots))))
  (when (f-directory-p project)
    (unless name
      (setq name (f-filename project)))
    (persp-switch name)

    (let ((recent-files (thread-last recentf-list
                                     (--filter (s-starts-with? project it))
                                     (-take 3)))
          (readme-org (f-join project "README.org"))
          (readme-md  (f-join project "README.md"))
          (readme-rst (f-join project "README.rst")))
      (cond
       (files                  (ha--project-show-files project files))
       (recent-files           (ha--project-show-files project recent-files))
       ((f-exists? readme-org) (find-file readme-org))
       ((f-exists? readme-md)  (find-file readme-md))
       ((f-exists? readme-rst) (find-file readme-rst))
       (t                      (dired project))))))

(defun ha--project-show-files (root files)
  "Display a list of FILES in a project ROOT directory.
Each file gets its own window (so don't make the list of files
long)."
  (when files
    (let ((default-directory root)
          (file (car files))
          (more (cdr files)))
      (message "Loading files from %s ... %s and %s" root file more)
      (when (f-exists? file)
        (find-file file))
      (when more
        (split-window-horizontally)
        (ha--project-show-files root more)))))