;;; Emacs init.el  -*- lexical-binding: t; -*-
;; by Case Duckworth <acdw@acdw.net>
;; Bankruptcy 10: "Annoyance"

;;; Commentary:

;; This is my Emacs configuration.  There are many like it but this
;; one is mine.
;;
;; For the tenth time!

;;; Packages

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

(dolist (pkg `(consult
               marginalia
               visual-fill-column
               adaptive-wrap
               geiser
               ,(when (executable-find "csi") 'geiser-chicken)
               avy
               zzz-to-char
               hungry-delete
               undohist
               jinx))
  (when (and pkg (not (package-installed-p pkg)))
    (unless (ignore-errors (package-install pkg))
      (package-refresh-contents)
      (package-install pkg))))

(load (locate-user-emacs-file "definitions"))
(load (locate-user-emacs-file "packages"))
(load (locate-user-emacs-file "private"))

(setopt custom-file (locate-user-emacs-file "custom.el"))
(load custom-file :noerror)

;;; General keybinding changes

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

(keymap-global-set "M-SPC" #'cycle-spacing@)

(keymap-global-set "M-u" #'universal-argument)
(keymap-set universal-argument-map "M-u" #'universal-argument-more)

;;; Theme

(if (daemonp)
    (add-hook 'server-after-make-frame-hook #'first-frame@set-fonts)
  (run-with-idle-timer 1 nil #'first-frame@set-fonts))

(tool-bar-mode -1)

(load-theme 'modus-vivendi :no-confirm :no-enable)
(load-theme 'modus-operandi :no-confirm)

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

;;; Mode line

(defvar mode-line-position
  '(""
    (:eval (if line-number-mode "%3l" ""))
    (:eval (if column-number-mode
               (if column-number-indicator-zero-based
                   "/%2c"
                 "/%2C")
             ""))
    " (" (-3 "%p") ") "))

(setopt mode-line-format
        '(("%e" mode-line-front-space
           mode-line-client
           mode-line-modified
           mode-line-remote " "
           mode-line-buffer-identification
           (vc-mode vc-mode)
           " "
           (mode-line-position mode-line-position)
           mode-line-modes
           mode-line-misc-info
           mode-line-end-spaces)))

;; Remove modes from mode-line
(dolist (minor-mode '(frowny-mode
                      whitespace-mode
                      hungry-delete-mode))
  (setf (alist-get minor-mode minor-mode-alist) (list ""))
  (add-hook (intern (format "%s-hook" minor-mode))
            (lambda ()
              (setf (alist-get minor-mode minor-mode-alist) (list "")))))

;;; Completion & minibuffer

(setopt icomplete-in-buffer t
        icomplete-tidy-shadowed-file-names t)
(fido-vertical-mode)

(setopt completion-auto-help (not icomplete-mode)
        completion-auto-select 'second-tab
        completions-header-format nil
        completions-max-height 12
        completions-format 'one-column
        completion-styles '(basic partial-completion flex)
        completion-ignore-case t
        read-buffer-completion-ignore-case t
        read-file-name-completion-ignore-case t
        completions-detailed t
        enable-recursive-minibuffers t
        file-name-shadow-properties '(invisible t intangible t)
        minibuffer-eldef-shorten-default t
        minibuffer-prompt-properties '( read-only t
                                        cursor-intangible t
                                        face minibuffer-prompt)
        window-resize-pixelwise t
        frame-resize-pixelwise t)

(add-hook 'completion-list-mode-hook #'truncate-lines-mode)
(add-hook 'minibuffer-setup-hook #'truncate-lines-mode)

;; Up/down when completing in the minibuffer
(define-key minibuffer-local-map (kbd "C-p") #'minibuffer-previous-completion)
(define-key minibuffer-local-map (kbd "C-n") #'minibuffer-next-completion)

;; Up/down when competing in a normal buffer
(define-key completion-in-region-mode-map (kbd "C-p") #'minibuffer-previous-completion)
(define-key completion-in-region-mode-map (kbd "C-n") #'minibuffer-next-completion)

(setopt completions-sort #'renz/sort-multi-category)

(setopt tab-always-indent 'complete)

(file-name-shadow-mode)
(minibuffer-electric-default-mode)

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

(add-hook 'prog-mode-hook #'indent-tabs-mode-maybe)

(setopt electric-pair-skip-whitespace 'chomp)
(electric-pair-mode)

(setopt sh-basic-offset tab-width)

(keymap-set emacs-lisp-mode-map "C-c C-c" #'eval-defun)
(keymap-set emacs-lisp-mode-map "C-c C-k" #'eval-buffer)
(keymap-set lisp-interaction-mode-map "C-c C-c" #'eval-defun)
(keymap-set lisp-interaction-mode-map "C-c C-k" #'eval-buffer)

(advice-add 'indent-region :around #'call-with-region-or-buffer)
(advice-add 'tabify :around #'call-with-region-or-buffer)
(advice-add 'untabify :around #'call-with-region-or-buffer)

(with-eval-after-load 'scheme
  (keymap-unset scheme-mode-map "M-o" t)
  ;; Comparse "keywords" --- CHICKEN (http://wiki.call-cc.org/eggref/5/comparse)
  (put 'sequence* 'scheme-indent-function 1)
  (put 'satisfies 'scheme-indent-function 1)
  (add-hook 'scheme-mode-hook #'geiser-mode))
(with-eval-after-load 'geiser-mode
  (keymap-set geiser-mode-map "C-c C-k" #'geiser-eval-buffer-and-go)
  (keymap-unset geiser-mode-map "C-." t))

(setopt visual-fill-column-center-text t
        visual-fill-column-width (+ fill-column 2))
(advice-add 'text-scale-adjust :after #'visual-fill-column-adjust)
(add-hook 'visual-line-mode-hook #'visual-fill-column-mode)
(add-hook 'visual-line-mode-hook #'adaptive-wrap-prefix-mode)

(setopt major-mode
        (lambda () ; guess major mode from buffer name
          (unless buffer-file-name
            (let ((buffer-file-name (buffer-name)))
              (set-auto-mode)))))

;; Dialogs
(unless (boundp 'use-short-answers)
  (fset 'yes-or-no-p 'y-or-n-p))

(setopt read-answer-short t
        use-dialog-box nil
        use-file-dialog nil
        use-short-answers t)

(require 'savehist)
(setopt history-length 1024
        history-delete-duplicates t
        ;; savehist-file (etc/ "savehist.el")
        savehist-save-minibuffer-history t
        savehist-autosave-interval 30)
(savehist-mode)

;; Killing and yanking
(setopt kill-do-not-save-duplicates t
        kill-read-only-ok t
        ;; XXX: This setting causes an error message the first time it's
        ;; called: "Selection owner couldn't convert: TIMESTAMP".          I have
        ;; absolutely no idea why I get this error, but it's generated in
        ;; `x_get_foreign_selection'.  I also can't inhibit the message or
        ;; do anything else with it, so for now, I'll just live with the
        ;; message.
        save-interprogram-paste-before-kill t
        yank-pop-change-selection t)
(delete-selection-mode)

;; Notifying the user
(setopt echo-keystrokes 0.01
        ring-bell-function #'ignore)

;; Point and mark
(setopt set-mark-command-repeat-pop t)

;; The system
(setopt read-process-output-max (* 10 1024 1024))

;; Startup
(setopt inhibit-startup-screen t
        initial-buffer-choice t
        initial-scratch-message nil)

(define-advice startup-echo-area-message (:override ())
  (if (get-buffer "*Warnings*")
      ";_;"
    "^_^"))

;; Text editing
(setopt fill-column 80
        sentence-end-double-space nil
        tab-width 8
        tab-always-indent 'complete)
(global-so-long-mode)

(setopt show-paren-delay 0.01
        show-paren-style 'parenthesis
        show-paren-when-point-in-periphery t
        show-paren-when-point-inside-paren t)
(show-paren-mode)


;; Encodings
(set-language-environment "UTF-8")
(setopt buffer-file-coding-system 'utf-8-unix
        coding-system-for-read 'utf-8-unix
        coding-system-for-write 'utf-8-unix
        default-process-coding-system '(utf-8-unix . utf-8-unix)
        locale-coding-system 'utf-8-unix)
(set-charset-priority 'unicode)
(prefer-coding-system 'utf-8-unix)
(set-default-coding-systems 'utf-8-unix)
(set-terminal-coding-system 'utf-8-unix)
(set-keyboard-coding-system 'utf-8-unix)
(pcase system-type
  ((or 'ms-dos 'windows-nt)
   (set-clipboard-coding-system 'utf-16-le)
   (set-selection-coding-system 'utf-16-le))
  (_
   (set-selection-coding-system 'utf-8)
   (set-clipboard-coding-system 'utf-8)))


;; Files
(setopt auto-revert-verbose nil
        global-auto-revert-non-file-buffers t
        create-lockfiles nil
        find-file-visit-truename t
        mode-require-final-newline t
        view-read-only t
        save-silently t)
(global-auto-revert-mode)

(setopt auto-save-default nil
        auto-save-interval 1
        auto-save-no-message t
        auto-save-timeout 1
        auto-save-visited-interval 1
        remote-file-name-inhibit-auto-save-visited t)
(add-to-list 'auto-save-file-name-transforms
             `(".*" ,(locate-user-emacs-file "auto-save/") t))
(auto-save-visited-mode)

(setopt backup-by-copying t
        version-control t
        kept-new-versions 8
        kept-old-versions 8
        delete-old-versions t)
(setq-default backup-directory-alist
              `(("^/dev/shm" . nil)
                ("^/tmp" . nil)
                (,(getenv "XDG_RUNTIME_DIR") . nil)
                ("." . ,(locate-user-emacs-file "backup"))))

(require 'recentf)
(setopt
 recentf-max-menu-items 500
 recentf-max-saved-items nil ; Save the whole list
 recentf-auto-cleanup 'mode
 recentf-case-fold-search t)
;; (add-to-list 'recentf-exclude etc/)
(add-to-list 'recentf-exclude "-autoloads.el\\'")
(add-hook 'buffer-list-update-hook #'recentf-track-opened-file)
(add-hook 'after-save-hook #'recentf-save-list)
(recentf-mode)

(require 'saveplace)
(setopt
 save-place-forget-unreadable-files (eq system-type
                                        'gnu/linux))
(save-place-mode)

(require 'uniquify)
(setq uniquify-after-kill-buffer-p t
      uniquify-buffer-name-style 'forward
      uniquify-ignore-buffers-re "^\\*"
      uniquify-separator path-separator)

(setq-local vc-follow-symlinks t
            vc-make-backup-files t)

;; Whitespace
(require 'whitespace)
(setopt whitespace-style
        '(face trailing tabs tab-mark))
(global-whitespace-mode)
(add-hook 'before-save-hook #'delete-trailing-whitespace-except-current-line)

;; Native compilation
(setopt native-comp-async-report-warnings-errors 'silent
        native-comp-deferred-compilation t
        native-compile-target-directory
        (locate-user-emacs-file "eln"))
(when (boundp 'native-comp-eln-load-path)
  (add-to-list 'native-comp-eln-load-path native-compile-target-directory))
(when (fboundp 'startup-redirect-eln-cache)
  (startup-redirect-eln-cache native-compile-target-directory))

(global-goto-address-mode)

;; Winner
(winner-mode)

;;; Hooks
(add-hook 'after-save-hook #'executable-make-buffer-file-executable-if-script-p)
(add-hook 'find-file-not-found-functions #'create-missing-directories)
(add-hook 'find-file-hook #'vc-remote-off)
(add-hook 'dired-mode-hook #'hl-line-mode)
(add-hook 'org-agenda-mode-hook #'hl-line-mode)

;;; Tab bar

(defun tab-bar-end-space ()
  `((end menu-item " " ignore)))

(setopt tab-bar-show t)
(add-to-list 'tab-bar-format 'tab-bar-format-align-right :append)
(add-to-list 'tab-bar-format 'tab-bar-format-global :append)
(add-to-list 'tab-bar-format 'tab-bar-end-space :append)
(tab-bar-mode)

;;; Org mode

(keymap-global-set "C-c a" #'org-agenda)
(setopt org-clock-clocked-in-display 'frame-title
        org-clock-frame-title-format
        '("%b" " - " (t org-mode-line-string)))

;;; Spelling

(defun list-of-strings-p (x)
  "Is X a list of strings?"
  (and x
       (listp x)
       (cl-every #'stringp x)))

(put 'ispell-local-words 'safe-local-variable
     'list-of-strings-p)

(add-hook 'text-mode-hook #'jinx-mode)
(with-eval-after-load 'jinx
  (keymap-set jinx-mode-map "M-$" #'jinx-correct)
  (keymap-set jinx-mode-map "C-M-$" #'jinx-languages))

;;; Copy rich text to the keyboard

;; Thanks to Oleh Krehel:
;; https://emacs.stackexchange.com/questions/54292/copy-results-of-org-export-directly-to-clipboard
;; So.  Emacs can't do this itself because it doesn't support sending clipboard
;; or selection contents as text/html.  We have to use xclip instead.
;; (defun org-to-html-to-clipboard (&rest org-export-args)
;;   "Export current org buffer to HTML, then copy it to the clipboard.
;; ORG-EXPORT-ARGS are passed to `org-export-to-file'."
;;   (let ((f (make-temp-file "org-html-export")))
;;     (apply #'org-export-to-file 'html f org-export-args)
;;     (start-process "xclip" " *xclip*"
;;                    "xclip" "-verbose" "-i" f
;;                    "-t" "text/html" "-selection" "clipboard")
;;     (message "HTML pasted to clipboard.")))

;; Wayland version.. TODO: make it work for both
(defun org-to-html-to-clipboard (&rest org-export-args)
  "Export current org buffer to HTML, then copy it to the clipboard.
ORG-EXPORT-ARGS are passed to `org-export-to-file'."
  (let ((buf (generate-new-buffer "*org-html-clipboard*" t)))
    (apply #'org-export-to-buffer 'html buf org-export-args)
    (with-current-buffer buf
      (call-process-region (point-min) (point-max)
                           "wl-copy" nil nil nil
                           "-t" "text/html")
      (kill-buffer-and-window))
    (message "HTML copied to clipboard.")))

(defun org-subtree-to-html-to-clipboard ()
  "Export current subtree to HTML."
  (interactive)
  (org-to-html-to-clipboard nil :subtree))

(undohist-initialize)

(require 'hungry-delete)
(setopt hungry-delete-chars-to-skip " \t"
        hungry-delete-skip-regexp (format "[%s]" hungry-delete-chars-to-skip)
        hungry-delete-join-reluctantly nil)
(add-to-list 'hungry-delete-except-modes 'eshell-mode)
(add-to-list 'hungry-delete-except-modes 'nim-mode)
(add-to-list 'hungry-delete-except-modes 'python-mode)
(global-hungry-delete-mode)

(setopt avy-background t
        avy-keys (string-to-list "asdfghjklqwertyuiopzxcvbnm"))
(keymap-global-set "M-j" #'avy-goto-char-timer)
(keymap-set isearch-mode-map "M-j" #'avy-isearch)
(keymap-global-set "M-z" #'zzz-to-char)

(marginalia-mode)

(keymap-global-set "C-x b" #'consult-buffer)
(keymap-global-set "C-x 4 b" #'consult-buffer-other-window)
(keymap-global-set "C-x 5 b" #'consult-buffer-other-frame)
(keymap-global-set "C-x r b" #'consult-bookmark)
(keymap-global-set "M-y" #'consult-yank-pop)
(keymap-global-set "M-g g" #'consult-goto-line)
(keymap-global-set "M-g M-g" #'consult-goto-line)
(keymap-global-set "M-g o" #'consult-outline)
(keymap-global-set "M-g m" #'consult-mark)
(keymap-global-set "M-g i" #'consult-imenu)
(keymap-global-set "M-s d" #'consult-find)
(keymap-global-set "M-s D" #'consult-locate)
(keymap-global-set "M-s g" #'consult-grep)
(keymap-global-set "M-s G" #'consult-git-grep)
(keymap-global-set "M-s r" #'consult-ripgrep)
(keymap-global-set "M-s l" #'consult-line)
(keymap-global-set "M-s k" #'consult-keep-lines)
(keymap-global-set "M-s u" #'consult-focus-lines)

(keymap-global-set "M-s e" #'consult-isearch-history)
(keymap-set isearch-mode-map "M-e" #'consult-isearch-history)
(keymap-set isearch-mode-map "M-s e" #'consult-isearch-history)
(keymap-set isearch-mode-map "M-s l" #'consult-line)

(keymap-set minibuffer-local-map "M-n" #'consult-history)
(keymap-set minibuffer-local-map "M-p" #'consult-history)

(setopt completion-in-region-function #'consult-completion-in-region
        xref-show-xrefs-function #'consult-xref
        xref-show-definitions-function #'consult-xref)

(setopt initial-scratch-message ";;; Emacs!\n\n")

(keymap-global-set "C-x C-b" #'ibuffer)
(add-hook 'ibuffer-hook #'hl-line-mode)