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

(progn ; performance stuff:
  ;; delay initial gc until after loading init if possible
  (setq gc-cons-threshold most-positive-fixnum)
  (add-hook 'emacs-startup-hook
            (lambda ()
              (setq gc-cons-threshold (expt 2 23)))))

(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))
(push "~/.emacs.d/site-lisp/" load-path)
(package-initialize)
(require 'use-package-ensure)
(setq use-package-always-ensure t)

(use-package benchmark-init
  :config
  (add-hook 'after-init-hook 'benchmark-init/deactivate))

(defvar surround-keys '("(" "{" "[" "$" "\"" "'"))
(defun my/wrap-pair ()
  "Ensure the region is active and then insert-pair."
  (interactive)
  (activate-mark)
  (insert-pair))

(eval
 `(define-keymap
    :full nil
    :name "Surround"
    :prefix 'surround-prefix

    ,@(mapcan
       (lambda (key) (list key ''my/wrap-pair))
       surround-keys
       )))

(defun my/toggle-frame-transparency ()
  "Toggle transparency."
  (interactive)
  (let ((alpha-transparency 90))
    (if (eq alpha-transparency (frame-parameter nil 'alpha-background))
        (set-frame-parameter nil 'alpha-background 100)
      (set-frame-parameter nil 'alpha-background alpha-transparency))))

(defvar my/prog-cleanup-excluded-modes
  '(makefile-gmake-mode makefile-mode makefile-imake-mode
                        makefile-makepp-mode makefile-bsdmake-mode makefile-automake-mode))

(defvar my/prog-cleanup-want-tabs-modes
  '(makefile-gmake-mode makefile-mode makefile-imake-mode
                        makefile-makepp-mode makefile-bsdmake-mode makefile-automake-mode))

(defvar my/prog-cleanup-indent-max-lines 500)

(defun my/clean-prog-file (&optional buffer)
  "Fixes whitespace etc in BUFFER or current buffer."
  (unless buffer (setq buffer (current-buffer)))
  (with-current-buffer buffer
    (when (< (car (buffer-line-statistics buffer))
               my/prog-cleanup-indent-max-lines)
      (indent-region (point-min) (point-max)))
    (unless (member major-mode my/prog-cleanup-want-tabs-modes)
      (untabify (point-min) (point-max)))
    (delete-trailing-whitespace)))

(defun my/prog-buffer-setup ()
  "Do setup in for mode buffers."
  (superword-mode 1)
  (modify-syntax-entry ?_ "w")
  (hs-minor-mode 1)
  (display-fill-column-indicator-mode 1)
  (smerge-mode 1)
  (add-hook 'before-save-hook
            (lambda ()
              (unless (member major-mode my/prog-cleanup-excluded-modes)
                (my/clean-prog-file)))))

(defun my/wrap-region-paren ()
  "Wraps the region in parens.  Similar to pressing ( with the region active."
  (interactive)
  (let ((beg (region-beginning))
        (end (region-end)))
    (save-excursion
      (goto-char beg)
      (insert "(")
      (goto-char (+ end 1))
      (insert ")"))))

(defun my/zap-whitespace ()
  "Zaps (deletes) the whitespace around the point in both directions."
  (interactive)
  (push-mark)
  (skip-chars-backward " \t\n")
  (push-mark)
  (skip-chars-forward " \t\n")
  (delete-region (mark) (point))
  (pop-mark)
  (goto-char (mark))
  (pop-mark))

(defun my/wrap-sexp (&optional arg)
  "Wraps the following sexp in a pair of parens.
Places inside the new pair, with prefix arg do the same backwards, pushing the
mark.  Does the same of ARG number sexps if given"
  (interactive "p")
  (message "%s" arg)
  (if arg
      (progn
        (push-mark)
        (insert-pair arg ?\( ?\)))
    (insert-pair 1 ?\( ?\))))

(defun my/close-or-kill ()
  "If this is the sole frame, kill emacs.  Otherwise close the frame."
  (interactive)
  (save-buffers-kill-terminal))

(defun my/toggle-window-other-reachability ()
  "Toggle whether this window can be selected by `other-window'."
  (interactive)
  (let* ((win (get-buffer-window (current-buffer)))
         (current (window-parameter win 'no-other-window)))
    (set-window-parameter win 'no-other-window (not current))))

(advice-add 'mode-line-window-control :around
            (lambda (f) (concat (funcall f)
                                (if (window-parameter nil 'no-other-window) "o" "")))
            '(:name "other-window-indicator"))

(defun my/open-window-by-buffer (buffer)
  "Move focus to an extant window by the buffer it contains."
  (interactive "bBuffer: ")
  (let ((win (get-buffer-window buffer t)))
    (if win
        (select-window win)
      (switch-to-buffer buffer))))

(defun my/shorten-path (path)
  "Shortens each directory in PATH except for the last directory to
its first character."
  (let* ((components (split-string path "/"))
         (last-component (-last (lambda (s) (not (string-empty-p s))) components))
         (shortened-components
          (mapcar (lambda (comp)
                    (if (or (string-equal comp last-component) (string-empty-p comp))
                        comp
                      (substring comp 0 1)))
                  components)))
    (mapconcat 'identity shortened-components "/")))

(defun my/swap-other-window-buffer ()
  "Try to switch the buffer contents of the current window and the
next in the cyclic ordering.  Don't involve windows that are
dedicated."
  (interactive)
  (let* ((cw (get-mru-window nil nil nil t))
         (cb (window-buffer cw))
         (ow (next-window))
         (ob (window-buffer ow)))
    (unless (window-dedicated-p cw)
      (while (window-dedicated-p ow)
        (setq ow (next-window ow)
              ob (window-buffer ow)))
      (unless (eq cw ow)
        (progn
          (with-selected-window ow
            (switch-to-buffer cb))
          (with-selected-window cw
            (switch-to-buffer ob)))))))

(defun my/activate-mark ()
  "Activate the region a la `C-SPC C-SPC', but don't move the point.
Useful in combination with `query-replace' for acting on the region."
  (interactive)
  (if (region-active-p)
      (deactivate-mark)
    (activate-mark)))

(defun my/c-x-n-to-m-n (&optional keymap)
  "Rebind the keys starting with C-x [number] to M-[number] in the
given keymap or in the global keymap."
  (unless keymap (setq keymap global-map))
  (mapc (lambda (n)
          (let* ((from (concat "C-x " (format "%d" n)))
                 (to (concat "M-" (format "%d" n)))
                 (bind (keymap-lookup keymap from)))
            (keymap-set keymap to bind)))
        '(0 1 2 3 4 5 6 7 8 9)))
(my/c-x-n-to-m-n)

(defun my/keymap-keys (map)
  "Return a list of all key sequences in a keymap MAP recursively."
  (mapcan (lambda (c)
            (let ((ks (car c))
                  (km (cdr c))
                  (acc nil))
              (map-keymap (lambda (key bind)
                            (let ((kss (vconcat ks (vector key))))
                              (when (commandp bind)
                                (push kss acc))))
                          km)
              acc))
          (accessible-keymaps map)))

(defun my/eshell (&optional arg)
  "Create a new eshell or switch to an existing one.
With ARG, make anew shell.  If the current buffer is an eshell, switch
back to the previous selected buffer."
  (interactive "P")
  (if (eq major-mode 'eshell-mode)
      ;; switch back
      (switch-to-prev-buffer)
    (eshell arg)))

(defun my/vc-on-root (&optional arg)
  "Open a vc dir buffer at the project root.
With ARG, open a Dired buffer instead."
  (interactive "P")
  (let ((dir (project-root(project-current t))))
    (if arg
        (dired dir)
      (vc-dir dir))))

(defun my/kill-buffer (&optional arg)
  "Kill the current buffer.
With ARG kill the window as well."
  (interactive "P")
  (if arg
      (kill-buffer-and-window)
    (kill-buffer)))

(defvar my/layout-pair (cons nil nil) "Cons pair of window configurations.")
(add-hook 'after-init-hook
          (lambda ()
            (setq my/layout-pair (cons (current-window-configuration)
                                       (current-window-configuration)))))
(defun my/layout-swap (&optional arg)
  "Swap between the two saved configurations.  With ARG, don't save the
current layout."
  (interactive "P")
  (let ((left (car my/layout-pair))
        (right (cdr my/layout-pair)))
    (unless arg
      (setq left (current-window-configuration)))
    (set-window-configuration right t t)
    (setq my/layout-pair (cons right left))))

(progn ; my global keybinds
  (define-minor-mode my/keys-mode
    "Minor mode collecting global keybinds"
    :global t
    :keymap (make-sparse-keymap))

  ;; The keymaps in `emulation-mode-map-alists' take precedence over
  ;; `minor-mode-map-alist'
  (add-to-list 'emulation-mode-map-alists
               '((my/keys-mode . my/keys-keymap)))

  (setq delete-pair-blink-delay 0)

  (keymap-set my/keys-mode-map "C-x C-C" 'save-buffers-kill-terminal)
  (keymap-set my/keys-mode-map "C-x C-c" 'my/close-or-kill)
  (keymap-set my/keys-mode-map "C-x -" 'my/swap-other-window-buffer)
  (keymap-set my/keys-mode-map "C-x w o" 'my/toggle-window-other-reachability)
  (keymap-set my/keys-mode-map "M-w" 'copy-region-as-kill) ; make copying not flash cursor
  (keymap-set my/keys-mode-map "M-(" 'my/wrap-region-paren)
  (keymap-set my/keys-mode-map "M-z" 'my/zap-whitespace)
  (keymap-set my/keys-mode-map "C-M-z" 'my/wrap-sexp)
  (keymap-set my/keys-mode-map "M-o" 'other-window)
  (keymap-set my/keys-mode-map "M-RET" 'my/eshell)
  (keymap-set my/keys-mode-map "M-C" 'calc)
  (keymap-set my/keys-mode-map "M-K" 'my/kill-buffer)
  (keymap-set my/keys-mode-map "M-D" 'my/vc-on-root)
  (keymap-set my/keys-mode-map "M-U" 'scroll-lock-mode)
  (keymap-set my/keys-mode-map "M-Q" 'auto-fill-mode)
  (keymap-set my/keys-mode-map "M-A" 'beginning-of-line-text)
  (keymap-set my/keys-mode-map "M-R" 'my/layout-swap)
  (keymap-set my/keys-mode-map "M-W" 'switch-to-buffer)
  (keymap-set my/keys-mode-map "M-N" 'man)
  (keymap-set my/keys-mode-map "C-c R" 'raise-sexp)
  (keymap-set my/keys-mode-map "C-c r" 'delete-pair)
  (keymap-set my/keys-mode-map "M-S" 'surround-prefix)
  (keymap-set my/keys-mode-map "M-\"" 'my/activate-mark)

  (my/keys-mode 1))

(use-package server ; allow emacsclient
  :demand t
  :config
  (unless (server-running-p) (server-start)))

(use-package proced ; process editor
  :commands (proced)
  :config
  (setq-default proced-auto-update-flag t)
  (setq-default proced-auto-update-interval 1))

(use-package orderless ; ordering (minibuffer) completions
  :demand t
  :custom
  (orderless-skip-highlighting t)
  (completion-styles '(orderless basic))
  (completion-ignore-case t)
  (read-file-name-completion-ignore-case t)
  (read-buffer-completion-ignore-case t)
  (orderless-smart-case nil)
  (orderless-matching-styles
   '(orderless-prefixes orderless-initialism orderless-literal orderless-regexp)))

(use-package vertico ; better minibuffer complete
  :demand t
  :custom
  (vertico-cycle t)
  :config
  ;; (vertico-flat-mode)
  (vertico-mode 1))

(use-package posframe)
(use-package vertico-posframe
  :after vertico
  :demand t
  :custom
  (vertico-posframe-poshandler
   #'posframe-poshandler-frame-bottom-center)
  (vertico-posframe-size-function
   (lambda (buffer)
     (let ((w (frame-width)))
       (list
        :height (buffer-local-value 'vertico-posframe-height buffer)
        :min-height (or (buffer-local-value 'vertico-posframe-min-height buffer)
                        (let ((height (+ vertico-count 1)))
                          (min height (or (buffer-local-value 'vertico-posframe-height buffer) height))))
        :width w
        :min-width w))))
  :config
  (vertico-posframe-mode 1))

(use-package marginalia ; more info in minibuffer menus
  :demand t
  :custom
  (marginalia-max-relative-age 0)
  (marginalia-align 'right)
  :bind (:map minibuffer-local-map
              ("M-A" . 'marginalia-cycle))
  :config
  (marginalia-mode))

(use-package embark ; more actions from minibuffer
  :demand t
  :bind
  (("C-." . embark-act)
   ("C-," . embark-dwim)
   ("C-h B" . embark-bindings))
  :config
  ;; Hide the mode line of the Embark live/completions buffers
  (add-to-list 'display-buffer-alist
               '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
                 nil
                 (window-parameters (mode-line-format . none)))))

(use-package corfu ; in buffer completion
  :demand t
  :custom
  (corfu-cycle t)
  (corfu-quit-no-match t)
  :bind (("M-/" . completion-at-point))
  :init
  (defun my/corfu-commit-single ()
    "Complete without asking if there is only one candidate."
    (when (and (corfu--popup-visible-p)
               (= (length corfu--candidates) 1))
      (corfu-accept)))
  :hook (corfu-post-command . my/corfu-commit-single)
  :config
  (global-corfu-mode 1))

(use-package tempel
  :demand t
  :custom
  (tempel-path "~/.emacs.d/templates/*.eld")
  :bind (("M-+" . tempel-complete))
  :config
  (keymap-set tempel-map "<remap> <forward-word>" #'tempel-next)
  (keymap-set tempel-map "<remap> <backward-word>" #'tempel-previous))

(use-package dabbrev ; dynamic abbreviations
  :demand t
  :config
  (add-to-list 'dabbrev-ignored-buffer-modes 'exwm-mode)
  (add-to-list 'dabbrev-ignored-buffer-modes 'pdf-view-mode)
  (add-to-list 'dabbrev-ignored-buffer-modes 'tags-table-mode)
  (add-to-list 'dabbrev-ignored-buffer-modes 'doc-view-mode))

(use-package cape ; extend completion frameworks
  :demand t
  :bind ("C-c p" . cape-prefix-map)
  :config
  (advice-add 'pcomplete-completions-at-point :around 'cape-wrap-silent)
  ;; (advice-add 'pcomplete-completions-at-point :around 'cape-wrap-purify)
  (defvar completion-at-point-functions-always-include
    (list 'tags-completion-at-point-function 'cape-dabbrev 'cape-dict 'tempel-complete))
  ;; local settings should include t to also include global settings
  (setq completion-at-point-functions completion-at-point-functions-always-include))

(use-package tempel-collection
  :after tempel
  :demand t)

(progn ; dired directory editor
  (require 'dired)
  (defun dired-do-find-marked-files ()
    (interactive)
    (seq-do 'find-file (dired-get-marked-files)))
  (define-key dired-mode-map (kbd "C-o") 'dired-display-file)
  (define-key dired-mode-map (kbd "F") 'dired-do-find-marked-files))

(use-package ibuffer ; give a nice list of buffers with extra info
  :commands (ibuffer)
  :custom
  (ibuffer-formats
   '((mark modified read-only " "
           (name 50 50 :left :elide) ; was originally 18
           " "
           (size 9 -1 :right)
           " "
           (mode 16 16 :left :elide)
           " " filename-and-process)
     (mark " "
           (name 16 -1)
           " " filename)))
  :bind
  ("C-x C-b" . ibuffer))

(use-package ibuffer-vc ; group buffers by vcs directory
  :after ibuffer
  :demand t
  :hook
  (ibuffer .
           (lambda ()
             (ibuffer-vc-set-filter-groups-by-vc-root)
             (unless (eq ibuffer-sorting-mode 'alphabetic)
               (ibuffer-do-sort-by-alphabetic)))))

(use-package free-keys)

(use-package which-key ; show list of next keys after prefix & delay
  :demand t
  :config
  (which-key-mode 1))

(use-package winum ; binds for switching to windows by number
  :demand t
  :config
  (winum-mode 1))

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

(progn ; basic isearch
  ;; swap basic and regex binds
  (keymap-set global-map "C-s" 'isearch-forward-regexp)
  (keymap-set global-map "C-r" 'isearch-backward-regexp)
  (keymap-set global-map "C-M-s" 'isearch-forward)
  (keymap-set global-map "C-M-r" 'isearch-backward))

;; (use-package consult ; more encompassing buffer switch and searching
;;   :demand t
;;   :custom
;;   (consult-preview-excluded-buffers t)
;;   (consult-narrow-key ",")
;;   :bind
;;   ("C-x b" . consult-buffer)
;;   ("M-W" . consult-buffer)
;;   ("C-S-y" . consult-yank-from-kill-ring)
;;   ("M-g M-g" . consult-goto-line)
;;   ("C-S-s" . consult-line-multi)
;;   ("M-s g" . consult-grep)
;;   ("M-s G" . grep)
;;   ("M-s f" . consult-find)
;;   ;; move some standard binds
;;   ("M-s s" . consult-line))

;; (use-package embark-consult
;;   :after embark consult)

(use-package hl-todo ; highlight certain keywords
  :hook
  (prog-mode . hl-todo-mode))

(use-package visible-mark ; make the mark visible
  :demand t
  :custom-face
  (visible-mark-active
   ((t . (:foreground "black"
                      :background "deep pink"
                      :box (:line-width (-1 . -1)
                                        :color "deep pink"
                                        :style nil)))))
  :custom
  (visible-mark-max 1)
  :config
  (global-visible-mark-mode 1))

(use-package avy ; goto location by char pair and jump list
  :bind (("C-'" . avy-goto-char-2)
         ("M-G" . avy-goto-char-2))
  :custom
  (avy-all-windows nil)
  (avy-all-windows-alt 'all-frames))

(use-package balanced-windows ; auto rebalance windows
  :bind ("C-x w b" . balanced-windows-mode))

(use-package eshell ; emacs shell
  :demand t
  :config
  (use-package esh-help)
  (require 'em-hist)
  (require 'em-term)
  (setup-esh-help-eldoc)
  :bind (:map eshell-mode-map
              ("C-l" . eshell/clear))
  :hook (eshell-mode . eldoc-mode))

(use-package eat ; terminal override to make eshell behave better
  :demand t
  :custom
  (eat-enable-auto-line-mode t)
  :config
  (eat-eshell-mode)
  (eat-eshell-visual-command-mode)
  (let* ((desired-global-binds (my/keymap-keys my/keys-mode-map))
         (desired-prefixes (mapcar (lambda (ks)
                                     (let ((k1 (elt ks 0))
                                           (meta-mask ?\M-\0))
                                       (if (numberp k1)
                                           (if (equal ?\e k1)
                                               (vector k1 (elt ks 1))
                                             (let ((k-no-m (logand k1 (lognot meta-mask)))
                                                   (k-has-m (not (zerop (logand k1 meta-mask)))))
                                               (if k-has-m
                                                   (vector ?\e k-no-m)
                                                 (vector k1))))
                                         (vector k1))))
                                   desired-global-binds)))
    (mapc (lambda (ks)
            (add-to-list 'eat-semi-char-non-bound-keys ks)
            (add-to-list 'eat-eshell-semi-char-non-bound-keys ks))
          desired-prefixes)
    (eat-update-semi-char-mode-map)
    (eat-eshell-update-semi-char-mode-map)))


;; (add-to-list 'display-buffer-alist
;;              '("*shelldon:"
;;                (display-buffer-reuse-window display-buffer-in-previous-window display-buffer-in-side-window display-buffer-pop-up-window)
;;                (side . right)
;;                (slot . 0)
;;                (window-width . 80)))

(progn ; comint, doesn't play with use-package
  (require 'comint)
  (setq-default comint-scroll-to-bottom-on-input t)
  (setq-default comint-scroll-to-bottom-on-output t)
  (add-to-list 'comint-output-filter-functions #'comint-truncate-buffer)
  (add-to-list 'comint-output-filter-functions #'ansi-color-process-output))

(use-package bash-completion
  :demand t
  :config
  (add-hook 'shell-dynamic-complete-functions
            'bash-completion-dynamic-complete)
  :hook
  (eshell-mode . (lambda ()
                   (add-hook 'completion-at-point-functions
                             'bash-completion-capf-nonexclusive nil t))))

(use-package pinentry)

(use-package pass ; password integration
  :demand t
  :init
  (use-package password-store)
  (use-package auth-source-pass :init (auth-source-pass-enable))
  :custom
  (pass-suppress-confirmations t)
  (epg-pinentry-mode 'loopback)
  :config
  (push '("\\*Password-Store\\*"
          display-buffer-in-side-window
          (side . right))
        display-buffer-alist))

(use-package tramp ; remote access for files
  :demand t
  :custom
  (tramp-allow-unsafe-temporary-files t))

(use-package asm-mode ; asm comments and tags generation
  :demand t
  :custom
  (asm-comment-char ?#) ; prefer # over ; for asm comments
  :init
  (defun add-asm-label-tag-generation-hook ()
    (add-hook 'after-save-hook
              (lambda ()
                (shell-command
                 "find . -iregex '.*\\.[sS]' -exec etags -l none -r '/\\([a-zA-Z0-9\\-_]+\\):/\1/' {} +"))
              0 t))
  :hook
  (asm-mode . 'add-asm-label-tag-generation-hook))

(use-package pyvenv)

(use-package sideline ; put warnings on the side of the same line
  :init
  (use-package sideline-flycheck)
  (use-package sideline-flymake)
  :custom
  (sideline-backends-right '(sideline-flycheck sideline-flymake)))

(use-package flycheck
  :config
  ;; flymake stuff to be less annoying
  ;; (face-spec-set 'flycheck-note '((t :underline nil)))
  ;; (face-spec-set 'flycheck-info '((t :underline nil)))
  ;; (face-spec-set 'flycheck-warning '((t :underline nil)))
  ;; (face-spec-set 'flycheck-error '((t :underline nil)))
  :hook
  (prog-mode . flycheck-mode))

(progn ; better commenting binds
  (global-set-key (kbd "C-x C-;") 'comment-or-uncomment-region)
  (global-set-key (kbd "C-x ;") 'comment-line)
  (global-set-key (kbd "C-x :") 'comment-or-uncomment-region)
  ;; ^ duped for terminal w/o C-;
  )

(use-package imenu ; jump to items in the current buffer
  :bind
  ("M-i" . imenu)
  :custom
  (imenu-auto-rescan t)
  (imenu-flatten t))

(use-package xref ; jump to syntactic elements in project
  ;; (add-hook 'xref-backend-functions 'gxref-xref-backend)
  :bind ("M-I" . xref-find-definitions))

(use-package ediff
  :custom
  (ediff-window-setup-function 'ediff-setup-windows-plain))

(progn ; collected folding binds
  (define-prefix-command 'my/fold-map)
  (global-set-key (kbd "M-F") 'my/fold-map)
  (define-keymap :full nil
    :parent nil
    :suppress nil
    :keymap nil
    :name "my/fold-map"
    :prefix 'my/fold-map))

(use-package fold-this ; fold arbitrary region
  :init
  (defun my/fold-this-fold-forward (&optional arg)
    "Fold forward ARG number of sexps, defaulting to one."
    (interactive "p")
    (push-mark)
    (forward-sexp arg)
    (fold-this (mark) (point))
    (pop-mark))

  (defun my/fold-this-fold-backward (&optional arg)
    "Fold backward ARG number of sexps, defaulting to one."
    (interactive "p")
    (push-mark)
    (backward-sexp arg)
    (fold-this (point) (mark))
    (pop-mark))

  :bind (:map my/fold-map
              ("c" . fold-this)
              ("e" . fold-this-unfold-at-point)
              ("f" . my/fold-this-fold-forward)
              ("b" . my/fold-this-fold-backward)))

(progn ; hideshow folding
  (keymap-set my/fold-map (kbd "t") 'hs-toggle-hiding)
  (keymap-set my/fold-map (kbd "l") 'hs-hide-level))

(add-hook 'prog-mode-hook 'my/prog-buffer-setup)
(electric-pair-mode 1)
(setq enable-recursive-minibuffers t)
(setq frame-resize-pixelwise t)

(use-package haskell-mode
  :custom
  (haskell-tags-on-save t)
  (haskell-process-type 'cabal-repl)
  (haskell-process-auto-import-loaded-modules t)
  :hook (haskell-mode . interactive-haskell-mode))

(use-package rust-mode)

(use-package opam-switch-mode
  :config
  (when (and (file-exists-p "~/.opam") (executable-find "opam"))
    (opam-switch-set-switch "default")))
(use-package tuareg
  :after opam-switch-mode)
(use-package ocp-indent
  :after tuareg
  :hook (tuareg-mode . ocp-setup-indent))
(use-package merlin
  :after tuareg
  :hook (tuareg-mode . merlin-mode)
  :custom (merlin-command 'opam))

(use-package racket-mode)

(use-package compile
  :custom
  (compilation-always-kill t)
  (compilation-scroll-output t)
  :bind
  ("M-M" . 'recompile)
  :config
  ;; Allow compilation buffer to be dedicated across frames
  (push '("\\*compilation\\*" . (nil (reusable-frames . t))) display-buffer-alist)
  (add-hook 'compilation-filter-hook #'ansi-color-compilation-filter))

(use-package man
  :custom
  (Man-switches "-a"))

(use-package sdcv ; dictionary, requires sdcv install
  :demand t
  :config
  (define-prefix-command 'dict-map)
  (define-keymap :full nil
    :parent nil
    :suppress nil
    :keymap nil
    :name "dict-map"
    :prefix 'dict-map
    (kbd "w") 'sdcv-search-input
    (kbd "c") (lambda () (interactive)
                (activate-input-method 'pyim)
                (sdcv-search-input (read-from-minibuffer "Chinese Word: "
                                                         nil nil nil
                                                         nil nil t))
                (activate-input-method nil)))
  :bind (:map text-mode-map
              ("M-l" . 'dict-map)))

(use-package erc ; irc client
  :init
  (defun my/start-erc ()
    "Start erc and autojoin various channels"
    (interactive)
    (erc :server "irc.libera.chat" :port 6667))
  :custom
  (erc-modules '(services autojoin button completion fill imenu irccontrols list match menu
                          move-to-prompt netsplit networks readonly ring stamp track))
  (erc-nick "tccq")
  (erc-use-auth-source-for-nickserv-password t)
  (erc-autojoin-channels-alist '(("libera.chat"
                                  "#emacs" "#haskell" "#duskos" "#ocaml")))

  (erc-hide-list '("JOIN" "PART" "QUIT"))
  (erc-current-nick-highlight-type 'nick)
  (erc-keywords nil)
  (erc-track-exclude-types '("JOIN" "PART" "QUIT" "NICK" "MODE"))
  (erc-track-use-faces t)
  (erc-track-faces-priority-list '(erc-current-nick-face erc-keyword-face))
  (erc-track-priority-faces-only 'all))

(progn ; indent code when pasting
  (defvar yank-indent-modes '(prog-mode LaTeX-mode TeX-mode)
    "Modes in which to indent regions that are yanked (or yank-popped).")

  (defun yank-indent-func (&optional arg)
    (let* ((parents (derived-mode-all-parents major-mode))
           (helper (lambda (acc v) (or acc (member v yank-indent-modes))))
           (included (-reduce helper parents)))
      (when (and (not arg) included)
        (indent-region (region-beginning) (region-end)))))

  (advice-add 'yank :after 'yank-indent-func)
  (advice-add 'yank-pop :after 'yank-indent-func))

(use-package minions
  :demand t
  :config
  (minions-mode 1)
  :custom
  (minions-prominent-modes '(persp-mode auto-fill-mode eldoc-mode eglot-mode lsp-mode)))

(progn ; default modeline config additions
  (let ((dir '("" (:eval (let ((str (concat (format " [%s]  " (my/shorten-path default-directory)))))
                           (add-face-text-property
                            0 (length str)
                            '(:weight bold :foreground "green2")
                            t str)
                           str)))))
    (push dir global-mode-string)))

(progn ; comfy scratch buffer
  (require 'iimage)
  (setq inhibit-startup-screen t)
  (setq initial-scratch-message
        (concat (propertize ";; " 'invisible t)
                "</home/tmu/.emacs.d/splashLaputa.png>
;; scratch for lisp evaluation and unsaved text

"))
  (add-hook 'emacs-startup-hook
            (lambda ()
              (with-current-buffer "*scratch*"
                (emacs-lock-mode 'kill)
                (iimage-mode 1)))))

(progn ; confirm fewer things
  (setq kill-buffer-query-functions
        (delq 'process-kill-buffer-query-function kill-buffer-query-functions))
  (setq confirm-kill-processes nil)
  (setq async-shell-command-buffer 'new-buffer)
  (setq vc-follow-symlinks t))

(use-package ispell ; spellchecker
  :demand t
  :custom
  (ispell-personal-dictionary "/home/tmu/.aspell.en.pws")
  :config
  (defun ispell-mode (&optional arg)
    "Make some old packages work with modern ispell."
    (interactive)
    (ispell-minor-mode arg))
  (advice-add 'ispell-mode :before 'debug)
  (setq-default text-mode-hook (cons 'ispell-minor-mode (remove 'ispell-mode text-mode-hook))))

(use-package time
  :custom
  (display-time-day-and-date t)
  (display-time-24hr-format t))

(use-package battery)

(use-package ednc)

(progn ; viper
  (setq-default viper-want-ctl-h-help t)
  (setq-default viper-inhibit-startup-message 't)
  (setq-default viper-expert-level 5)
  (setq-default viper-is-in-minibuffer nil)
  (setq-default viper-vi-style-in-minibuffer nil)
  (setq-default viper-enable-minibuffer-faces nil)
  (setq-default viper-syntax-preference 'emacs)
  (setq-default viper-ex-style-motion nil)
  (setq-default viper-auto-indent t)
  (setq-default viper-buffer-search-char ?g)
  (setq viper-mode nil)
  (require 'viper)
  (define-key viper-vi-global-user-map (kbd "C-y") 'yank)
  (define-key viper-vi-global-user-map (kbd "C-e") 'end-of-line)
  (define-key viper-vi-global-user-map (kbd "C-f") 'forward-char)
  (define-key viper-vi-global-user-map (kbd "C-b") 'backward-char)
  (define-key viper-vi-global-user-map (kbd "C-u") 'universal-argument)
  (define-key viper-insert-global-user-map (kbd "C-u") 'universal-argument)
  (define-key viper-insert-global-user-map (kbd "C-d") 'delete-char)
  (define-key viper-insert-global-user-map (kbd "C-m")
              #'(lambda ()
                  (interactive)
                  (if completion-in-region-mode
                      (corfu-insert)
                    (viper-autoindent)))))

;; if you want exwm, include from ~/.emacs.d/site-lisp/my-exwm.el
;; if you want mail, include from ~/.emacs.d/site-lisp/my-mail.el
;; if you want eglot, include from ~/.emacs.d/site-lisp/my-eglot.el

;; ----------------------------------------------------------------------
;; theme stuff

(require 'tmu-custom-theme)
(push "~/.emacs.d/site-lisp/" custom-theme-load-path)
(load-theme 'tmu-custom t)

;; ----------------------------------------------------------------------
;; Things emacs sets programatically

(put 'dired-find-alternate-file 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'list-timers 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'set-goal-column 'disabled nil)

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(comment-style 'extra-line)
 '(connection-local-criteria-alist
   '(((:application eshell :protocol "ssh" :user "tmu" :machine
                    "cnoserver")
      autogenerated-connection-local-profile/\(:application\ eshell\ :protocol\ \"ssh\"\ :user\ \"tmu\"\ :machine\ \"cnoserver\"\))
     ((:application vc-git :protocol "ssh" :user "tmu" :machine
                    "cnoserver")
      autogenerated-connection-local-profile/\(:application\ vc-git\ :protocol\ \"ssh\"\ :user\ \"tmu\"\ :machine\ \"cnoserver\"\))
     ((:application vc-git) vc-git-connection-default-profile)
     ((:application tramp :protocol "kubernetes")
      tramp-kubernetes-connection-local-default-profile)
     ((:application tramp :protocol "flatpak")
      tramp-container-connection-local-default-flatpak-profile
      tramp-flatpak-connection-local-default-profile)
     ((:application tramp)
      tramp-connection-local-default-system-profile
      tramp-connection-local-default-shell-profile)
     ((:application eshell) eshell-connection-default-profile)))
 '(connection-local-profile-alist
   '((autogenerated-connection-local-profile/\(:application\ eshell\ :protocol\ \"ssh\"\ :user\ \"tmu\"\ :machine\ \"cnoserver\"\)
      (eshell-path-env-list "/bin" "/usr/bin" "/sbin" "/usr/sbin"
                            "/usr/local/bin" "/usr/local/sbin"))
     (autogenerated-connection-local-profile/\(:application\ vc-git\ :protocol\ \"ssh\"\ :user\ \"tmu\"\ :machine\ \"cnoserver\"\)
      (vc-git--program-version . "2.48.1"))
     (vc-git-connection-default-profile (vc-git--program-version))
     (tramp-flatpak-connection-local-default-profile
      (tramp-remote-path "/app/bin" tramp-default-remote-path "/bin"
                         "/usr/bin" "/sbin" "/usr/sbin"
                         "/usr/local/bin" "/usr/local/sbin"
                         "/local/bin" "/local/freeware/bin"
                         "/local/gnu/bin" "/usr/freeware/bin"
                         "/usr/pkg/bin" "/usr/contrib/bin" "/opt/bin"
                         "/opt/sbin" "/opt/local/bin"))
     (tramp-kubernetes-connection-local-default-profile
      (tramp-config-check . tramp-kubernetes--current-context-data)
      (tramp-extra-expand-args 97
                               (tramp-kubernetes--container
                                (car tramp-current-connection))
                               104
                               (tramp-kubernetes--pod
                                (car tramp-current-connection))
                               120
                               (tramp-kubernetes--context-namespace
                                (car tramp-current-connection))))
     (tramp-container-connection-local-default-flatpak-profile
      (tramp-remote-path "/app/bin" tramp-default-remote-path "/bin"
                         "/usr/bin" "/sbin" "/usr/sbin"
                         "/usr/local/bin" "/usr/local/sbin"
                         "/local/bin" "/local/freeware/bin"
                         "/local/gnu/bin" "/usr/freeware/bin"
                         "/usr/pkg/bin" "/usr/contrib/bin" "/opt/bin"
                         "/opt/sbin" "/opt/local/bin"))
     (tramp-connection-local-darwin-ps-profile
      (tramp-process-attributes-ps-args "-acxww" "-o"
                                        "pid,uid,user,gid,comm=abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                        "-o" "state=abcde" "-o"
                                        "ppid,pgid,sess,tty,tpgid,minflt,majflt,time,pri,nice,vsz,rss,etime,pcpu,pmem,args")
      (tramp-process-attributes-ps-format (pid . number)
                                          (euid . number)
                                          (user . string)
                                          (egid . number) (comm . 52)
                                          (state . 5) (ppid . number)
                                          (pgrp . number)
                                          (sess . number)
                                          (ttname . string)
                                          (tpgid . number)
                                          (minflt . number)
                                          (majflt . number)
                                          (time . tramp-ps-time)
                                          (pri . number)
                                          (nice . number)
                                          (vsize . number)
                                          (rss . number)
                                          (etime . tramp-ps-time)
                                          (pcpu . number)
                                          (pmem . number) (args)))
     (tramp-connection-local-busybox-ps-profile
      (tramp-process-attributes-ps-args "-o"
                                        "pid,user,group,comm=abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                        "-o" "stat=abcde" "-o"
                                        "ppid,pgid,tty,time,nice,etime,args")
      (tramp-process-attributes-ps-format (pid . number)
                                          (user . string)
                                          (group . string) (comm . 52)
                                          (state . 5) (ppid . number)
                                          (pgrp . number)
                                          (ttname . string)
                                          (time . tramp-ps-time)
                                          (nice . number)
                                          (etime . tramp-ps-time)
                                          (args)))
     (tramp-connection-local-bsd-ps-profile
      (tramp-process-attributes-ps-args "-acxww" "-o"
                                        "pid,euid,user,egid,egroup,comm=abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                        "-o"
                                        "state,ppid,pgid,sid,tty,tpgid,minflt,majflt,time,pri,nice,vsz,rss,etimes,pcpu,pmem,args")
      (tramp-process-attributes-ps-format (pid . number)
                                          (euid . number)
                                          (user . string)
                                          (egid . number)
                                          (group . string) (comm . 52)
                                          (state . string)
                                          (ppid . number)
                                          (pgrp . number)
                                          (sess . number)
                                          (ttname . string)
                                          (tpgid . number)
                                          (minflt . number)
                                          (majflt . number)
                                          (time . tramp-ps-time)
                                          (pri . number)
                                          (nice . number)
                                          (vsize . number)
                                          (rss . number)
                                          (etime . number)
                                          (pcpu . number)
                                          (pmem . number) (args)))
     (tramp-connection-local-default-shell-profile
      (shell-file-name . "/bin/sh") (shell-command-switch . "-c"))
     (tramp-connection-local-default-system-profile
      (path-separator . ":") (null-device . "/dev/null"))
     (eshell-connection-default-profile (eshell-path-env-list))))
 '(custom-safe-themes
   '("aee99e2118e960b53016623dc2345d88227d1236d28c6c34858e1d55575cf7c3"
     "6f5e3fd2b4245ffe660da69ea5c13ab392337e94776dfb23cc1d8d0f80e3baa2"
     "1b8c2fd98bf6777d8b95f8cf98fdaede88feee3419ec3e5008f94b56618ac6ca"
     "0cc5046b7981609166c28b64f6185fa5f73bcb00d21e037f304794c6aaa1f340"
     "9f2e4e8b2ddbfdd392eedbc123649d94654278dee5a53b899557224416413d35"
     "6dafb31ade9ff07229faaf05c41c2ae475c44731362b792f65f3930b1a2c9cfd"
     "dc77e008092a5a4aa6b6ed8e4826bebf8f2fb930a8de073bf7f458efd884cca8"
     "d1ff3e66028f9c527298580d2a64f9e3280f07f9e94d4dada72b67ef15069441"
     "3d4e3644e237a95683daa73e397c4c0d1ae06bbaaf8040104232591a28bc1315"
     "12a07bc38295e4b06a8965db261f51ea7ea61fbf91b3ef41298bbb549d1d9403"
     default))
 '(ede-project-directories
   '("/home/tmu/Desktop/eway/sway" "/home/tmu/Desktop/eway/cage"
     "/home/tmu/Desktop/eway/wlroots" "/home/tmu/Desktop/eway/comp"
     "/home/tmu/Desktop/eway"))
 '(eglot-events-buffer-config '(:size 0 :format full))
 '(fortune-dir "/usr/share/fortune/")
 '(gdb-non-stop-setting nil)
 '(helm-minibuffer-history-key "M-p")
 '(menu-bar-mode nil)
 '(package-selected-packages nil)
 '(pyim-assistant-scheme 'cangjie)
 '(safe-local-variable-values '((LEXICAL-binding . t)))
 '(scroll-bar-mode nil)
 '(tags-revert-without-query t)
 '(tool-bar-mode nil)
 '(transient-mark-mode nil)
 '(whitespace-style
   '(face trailing tabs lines-tail missing-newline-at-eof indentation
          space-after-tab space-before-tab tab-mark) t))

(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )