#+TITLE: Materus Emacs Cfg
#+AUTHOR: materus
#+DESCRIPTION: materus emacs configuration
#+STARTUP: overview
#+PROPERTY: header-args :tangle (expand-file-name "init.el" user-emacs-directory)
#+OPTIONS: \n:t
#+auto_tangle: t

* Early Init
#+begin_src emacs-lisp :tangle (expand-file-name "early-init.el" user-emacs-directory)  
  ;;; -*- lexical-binding: t; -*-
    
  ;;; VARIABLES


  (setenv "LSP_USE_PLISTS" "true")                                                          ; Make lsp-mode use plists

  (setq c-default-style nil)                                                                ; Clear default styles for languages, will set them up later
  (setq default-input-method nil)                                                           ; Disable default input method, I'm not using them anyway so far
  (setq initial-major-mode 'fundamental-mode)                                               ; Use fundamental mode in scratch buffer, speed up loading, not really important when emacs used as daemon
  (setq auto-save-default nil)                                                              ; TODO: configure auto saves, disable for now
  (setq backup-directory-alist
        `((".*" . ,(concat user-emacs-directory "var/backups/"))))                          ; Set backup location
  (setq auto-save-file-name-transforms
        `((".*" ,(concat user-emacs-directory "var/recovery/") t)))                         ; Set auto-save location  
  (setq auto-save-list-file-prefix (concat user-emacs-directory "var/auto-save/sessions/")) ; Set auto-save-list location
  (setq load-prefer-newer t)                                                                ; Prefer newer files to load


  (setq package-enable-at-startup nil)                                                       
  (setq package-quickstart nil)                                                             ; Disable package quickstart

  (setq inhibit-startup-screen t)
  
  (setq inhibit-compacting-font-caches t)                                                   ; Don't compact fonts

  (set-language-environment "UTF-8")                                                        ; Use UTF-8
  (setq-default buffer-file-coding-system 'utf-8-unix)

  (setq custom-file (concat user-emacs-directory "etc/custom.el"))                          ; Set custom file location, don't want clutter in main directory
  (setq custom-theme-directory
        (concat user-emacs-directory "/etc/materus/themes" ))                               ; Set custom themes location

  (setq ring-bell-function 'ignore)                                                         ; Disable bell


  (defvar materus/emacs-gc-cons-threshold (* 64 1024 1024)
    "The value of `gc-cons-threshold' after Emacs startup.")                                ; Define after init garbage collector threshold


  ;;; GARBAGE COLLECTOR 
  (setq gc-cons-threshold most-positive-fixnum)                                             ; Set `gc-cons-threshold' so it won't collectect during initialization 

  (add-hook 'emacs-startup-hook
            (lambda ()
              (setq gc-cons-threshold materus/emacs-gc-cons-threshold)))                    ; Set `gc-cons-threshold' to desired value after startup




  ;;; FRAMES

  (setq frame-inhibit-implied-resize t)
  (setq frame-resize-pixelwise t)
  (setq window-resize-pixelwise t)                                ; Allow pixelwise resizing of window and frame

  (unless (daemonp)
    (add-to-list 'initial-frame-alist '(fullscreen . maximized))) ; Start first frame maximized if not running as daemon, daemon frame are set up later in config
  (setq default-frame-alist                                       ; Set default size for frames
        '((width . 130)   
          (height . 40)))                 

  (advice-add #'tty-run-terminal-initialization :override #'ignore)
  (add-hook 'window-setup-hook
            (lambda ()
              (unless (display-graphic-p)
                (advice-remove #'tty-run-terminal-initialization #'ignore) 
                (tty-run-terminal-initialization (selected-frame) nil t)
                )))


  ;;; NATIVE COMPILATION

  (setq native-comp-async-report-warnings-errors nil) ; Silence warnings
  (setq native-comp-speed 3)                          ; Set native-comp speed

  (setq native-comp-jit-compilation t
        ;;native-comp-deferred-compilation t 
        package-native-compile t)


  ;; Setting up native-comp cache location

  (when (and (fboundp 'startup-redirect-eln-cache)
             (fboundp 'native-comp-available-p)
             (native-comp-available-p))
    (startup-redirect-eln-cache
     (convert-standard-filename
      (concat user-emacs-directory "var/eln-cache/"))))
#+end_src

* Init Core
** TMP
#+begin_src emacs-lisp
    ;;; -*- lexical-binding: t; -*-

  (when (not emacs-build-time)
    (print "WARN: emacs-build-time not set up, using current time")
    (setq emacs-build-time (decode-time (current-time))))
  (add-to-list 'load-path (concat user-emacs-directory "etc/materus/extra"))                ; Extra load path for packages
  (defvar electric-pair-inhibit-predicate nil)



  (defvar elpaca-installer-version 0.11)
  (defvar elpaca-directory (expand-file-name "var/elpaca/" user-emacs-directory))
  (defvar elpaca-builds-directory (expand-file-name (concat "builds/" emacs-version "/") elpaca-directory))
  (defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
  (defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                                :ref nil :depth 1 :inherit ignore
                                :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                                :build (:not elpaca--activate-package)))
  (let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
         (build (expand-file-name "elpaca/" elpaca-builds-directory))
         (order (cdr elpaca-order))
         (default-directory repo))
    (add-to-list 'load-path (if (file-exists-p build) build repo))
    (unless (file-exists-p repo)
      (make-directory repo t)
      (when (<= emacs-major-version 28) (require 'subr-x))
      (condition-case-unless-debug err
          (if-let* ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
  		  ((zerop (apply #'call-process `("git" nil ,buffer t "clone"
                                                    ,@(when-let* ((depth (plist-get order :depth)))
                                                        (list (format "--depth=%d" depth) "--no-single-branch"))
                                                    ,(plist-get order :repo) ,repo))))
                    ((zerop (call-process "git" nil buffer t "checkout"
                                          (or (plist-get order :ref) "--"))))
                    (emacs (concat invocation-directory invocation-name))
                    ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                          "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                    ((require 'elpaca))
                    ((elpaca-generate-autoloads "elpaca" repo)))
              (progn (message "%s" (buffer-string)) (kill-buffer buffer))
            (error "%s" (with-current-buffer buffer (buffer-string))))
        ((error) (warn "%s" err) (delete-directory repo 'recursive))))
    (unless (require 'elpaca-autoloads nil t)
      (require 'elpaca)
      (elpaca-generate-autoloads "elpaca" repo)
      (let ((load-source-file-function nil)) (load "./elpaca-autoloads"))))
  (add-hook 'after-init-hook #'elpaca-process-queues)
  (elpaca `(,@elpaca-order))

  (elpaca elpaca-use-package
    (elpaca-use-package-mode)
    (setq elpaca-use-package-by-default t))




  (use-package no-littering
    :config
    (require 'recentf)
    (setq package-quickstart-file  
          (concat user-emacs-directory "var/quickstart/package-quickstart-" emacs-version ".el" ))
    (add-to-list 'recentf-exclude
                 (recentf-expand-file-name no-littering-var-directory))
    (add-to-list 'recentf-exclude
                 (recentf-expand-file-name no-littering-etc-directory)))
  (use-package org
    :mode (("\\.org$" . org-mode))
    :hook
    ((org-mode . org-indent-mode)
     (org-mode . display-line-numbers-mode)
     )
    :config
    (require 'org-mouse)
    (require 'org-tempo)
    (setq org-src-window-setup 'current-window)
    (setq org-latex-pdf-process '("latexmk -xelatex -quiet -shell-escape -f -output-directory=%o %f"))
    (org-babel-do-load-languages
     'org-babel-load-languages
     '((latex . t)
       (emacs-lisp . t)
       (shell . t)
       (css . t)
       (C . t)
       (calc . t)
       (awk . t)
       (sql . t)
       (sqlite . t)))
    (add-hook 'org-mode-hook (lambda ()
                               (setq-local
                                electric-pair-inhibit-predicate
                                `(lambda (c)
                                   (if
                                       (char-equal c ?<) t (,electric-pair-inhibit-predicate c)))))))
  (elpaca-wait)



  ;;(load custom-file t)


#+end_src

** Lexical Binding

#+begin_src emacs-lisp
  ;;; -*- lexical-binding: t; -*-
#+end_src
** Font & Text
#+begin_src emacs-lisp
  (when (display-graphic-p)
     (set-frame-font "Hack Nerd Font" nil t))
  (setq-default cursor-type '(bar . 2))
  (setq truncate-string-ellipsis "…")


  (setq text-mode-ispell-word-completion nil) ; Disable ispell
  (global-completion-preview-mode 1)
#+end_src

** Frame
#+begin_src emacs-lisp
  (when (daemonp)
    (add-hook 'after-make-frame-functions 
              (lambda (frame) (when (= (length (frame-list)) 2)
                                (set-frame-parameter frame 'fullscreen 'maximized)) 
                (select-frame-set-input-focus frame) )))
  (global-tab-line-mode 1)
  (setq window-divider-default-bottom-width 1)
  (setq window-divider-default-right-width 1)
  (window-divider-mode 1)
  (tool-bar-mode -1)
  (setq-default display-line-numbers-width 3)
  (setq-default display-line-numbers-widen t)

   (defun startup-screen-advice (orig-fun &rest args)
    (when (= (seq-count #'buffer-file-name (buffer-list)) 0)
      (apply orig-fun args)))
  (advice-add 'display-startup-screen :around #'startup-screen-advice) ; Hide startup screen if started with file
#+end_src
** Mouse
Setting up mouse
#+begin_src emacs-lisp
  (context-menu-mode 1)
  (setq mouse-wheel-follow-mouse 't)
  (setq scroll-step 1)
  (setq mouse-drag-and-drop-region t)
  (xterm-mouse-mode 1)
  (pixel-scroll-precision-mode 1)
  (setq-default pixel-scroll-precision-large-scroll-height 10.0)
#+end_src
* Packages
** Theme
#+begin_src emacs-lisp
  (use-package dracula-theme :config
    (if (daemonp)
        (add-hook 'after-make-frame-functions
                  (lambda (frame)
                    (with-selected-frame frame (load-theme 'dracula t))))
      (load-theme 'dracula t)))

#+end_src
** org
#+begin_src emacs-lisp

  (use-package org-modern
    :after (org)
    :hook
    (org-indent-mode . org-modern-mode)
    (org-agenda-finalize . org-modern-agenda)
    :config 
    (setq org-modern-block-name '("▼ " . "▲ ")))
  (use-package org-auto-tangle
    :after (org)
    :hook (org-mode . org-auto-tangle-mode)
    )
  (use-package toc-org
    :after (org)
    :hook
    ((org-mode . toc-org-mode )
     (markdown-mode . toc-org-mode)))

#+end_src
** rainbow-mode
#+begin_src emacs-lisp
  (use-package rainbow-mode
    :hook
    ((org-mode . rainbow-mode)
     (prog-mode . rainbow-mode)))
#+end_src
** delimiters
#+begin_src emacs-lisp
  (use-package rainbow-delimiters
    :hook
    (prog-mode . rainbow-delimiters-mode)
    :config
    (set-face-attribute 'rainbow-delimiters-depth-1-face nil :foreground "#FFFFFF")
    (set-face-attribute 'rainbow-delimiters-depth-2-face nil :foreground "#FFFF00")
    (set-face-attribute 'rainbow-delimiters-depth-5-face nil :foreground "#6A5ACD")
    (set-face-attribute 'rainbow-delimiters-unmatched-face nil :foreground "#FF0000"))

#+end_src
** eat
#+begin_src emacs-lisp
  (use-package eat
    :config
    (defvar cua--eat-semi-char-keymap (copy-keymap cua--cua-keys-keymap) "EAT semi-char mode CUA keymap")
    (defvar cua--eat-char-keymap (copy-keymap cua--cua-keys-keymap) "EAT char mode CUA keymap"))

#+end_src

** Undo-tree
#+begin_src emacs-lisp
  (use-package undo-tree
    :config
    (global-undo-tree-mode 1)
    (defvar materus/undo-tree-dir (concat user-emacs-directory "var/undo-tree/"))
    (unless (file-exists-p materus/undo-tree-dir)
      (make-directory materus/undo-tree-dir t))
    (setq undo-tree-visualizer-diff t)
    (setq undo-tree-history-directory-alist `(("." . ,materus/undo-tree-dir )))
    (setq undo-tree-visualizer-timestamps t))

#+end_src

** Dirvish
#+begin_src emacs-lisp
  (use-package dirvish
    :after (nerd-icons)
   :config
   (setq dired-mouse-drag-files t)
   (dirvish-override-dired-mode 1)
   (setq dirvish-attributes
         '(vc-state
           subtree-state
           nerd-icons
           collapse
           git-msg
           file-time 
           file-size)))

#+end_src
** orderless
#+begin_src emacs-lisp
   (use-package orderless
    :init
    ;; Tune the global completion style settings to your liking!
    ;; This affects the minibuffer and non-lsp completion at point.
    (setq completion-styles '(basic partial-completion orderless)
          completion-category-defaults nil
          completion-category-overrides nil))
#+end_src
** minibuffer
#+begin_src emacs-lisp
  (use-package consult)
  (use-package marginalia)

  (use-package which-key
    :config
    (which-key-mode 1))

  (use-package vertico
    :after (consult marginalia)
    :config
    (setq completion-in-region-function
          (lambda (&rest args)
            (apply (if vertico-mode
                       #'consult-completion-in-region
                     #'completion--in-region)
                   args)))
    (vertico-mode 1)
    (marginalia-mode 1))
  (use-package vertico-mouse
    :config
    (vertico-mouse-mode 1)
    :ensure nil
    :after (vertico))
#+end_src

** nerd-icons
#+begin_src emacs-lisp
  (use-package nerd-icons)
  (use-package nerd-icons-completion
    :after (marginalia)
    :config 
    (nerd-icons-completion-mode 1)
    (add-hook 'marginalia-mode-hook #'nerd-icons-completion-marginalia-setup))

#+end_src
** diff-hl
#+begin_src emacs-lisp
  (use-package diff-hl
    :config
    (setq diff-hl-side 'right)
    (global-diff-hl-mode 1)
    (diff-hl-margin-mode 1)
    (diff-hl-flydiff-mode 1)
    (global-diff-hl-show-hunk-mouse-mode 1))

#+end_src

** modelinne
#+begin_src emacs-lisp
  ;; (use-package doom-modeline
  ;;   :init (setq doom-modeline-support-imenu t)
  ;;   :hook (elpaca-after-init . doom-modeline-mode)
  ;;   :config
  ;;   (setq doom-modeline-icon t)
  ;;   (setq doom-modeline-project-detection 'auto)
  ;;   (setq doom-modeline-height 20)
  ;;   (setq doom-modeline-enable-word-count t)
  ;;   (setq doom-modeline-minor-modes t)
  ;;   (setq display-time-24hr-format t)
  ;;   (display-time-mode 1)
  ;;   (column-number-mode 1)
  ;;   (line-number-mode 1))

  (use-package minions
    :hook (elpaca-after-init . minions-mode))
#+end_src

** dashboard
#+begin_src emacs-lisp
  (use-package dashboard
    :after (nerd-icons projectile)
    :config
    (setq dashboard-center-content t)
    (setq dashboard-display-icons-p t)
    (setq dashboard-icon-type 'nerd-icons)
    (setq dashboard-projects-backend 'projectile)
    (setq dashboard-items '((recents   . 5)
                            (bookmarks . 5)
                            (projects  . 5)
                            (agenda    . 5)
                            (registers . 5)))
    (when (or (daemonp) (< (length command-line-args) 2))
      (add-hook 'elpaca-after-init-hook #'dashboard-insert-startupify-lists)
      (add-hook 'elpaca-after-init-hook #'dashboard-initialize)
      (dashboard-setup-startup-hook)))
  (when (daemonp)
    (setq initial-buffer-choice (lambda () (get-buffer "*dashboard*")))) ; Show dashboard when emacs is running as daemon)

    #+end_src
** treemacs
#+begin_src emacs-lisp
  (use-package treemacs)
  (use-package treemacs-projectile
    :after (projectile treemacs))
  (use-package treemacs-nerd-icons
    :after (nerd-icons treemacs))
  (use-package treemacs-perspective
    :after (treemacs))
  (use-package treemacs-mouse-interface
    :after (treemacs)
    :ensure nil)

#+end_src

** magit

#+begin_src emacs-lisp
  (use-package transient)
  (use-package magit
    :after (transient))

#+end_src
** projectile
#+begin_src emacs-lisp
  (use-package projectile
    :config (projectile-mode 1))
#+end_src
** Perspective 
#+begin_src emacs-lisp
  (use-package  perspective
    :config
    (setq persp-mode-prefix-key (kbd "C-c M-p"))
    (setq persp-modestring-short t)
    (persp-mode 1)
    )
#+end_src
*** Elcord
#+begin_src emacs-lisp
  (defun materus/elcord-toggle (&optional _frame)
    "Toggle elcord based on visible frames"
    (if (> (length (frame-list)) 1)
        (elcord-mode 1)
      (elcord-mode -1))
    )
  (use-package elcord
    :config
    (unless (daemonp) (elcord-mode 1))
    (add-hook 'after-delete-frame-functions 'materus/elcord-toggle)
    (add-hook 'server-after-make-frame-hook 'materus/elcord-toggle))
#+end_src
** yasnippet
#+begin_src emacs-lisp 
  (use-package yasnippet
    :config
    (yas-global-mode 1))
#+end_src
** Code completion
#+begin_src emacs-lisp

  (use-package cape)

  (use-package corfu
    ;; Optional customizations
    :custom
    (corfu-cycle nil)                ;; Enable cycling for `corfu-next/previous'
    (corfu-auto t)                 ;; Enable auto completion
    (global-corfu-minibuffer nil)
    ;; (corfu-quit-at-boundary nil)   ;; Never quit at completion boundary
    ;; (corfu-quit-no-match nil)      ;; Never quit, even if there is no match
    (corfu-preview-current nil)    ;; Disable current candidate preview
    ;; (corfu-preselect 'prompt)      ;; Preselect the prompt
    ;; (corfu-on-exact-match nil)     ;; Configure handling of exact matches

    ;; Enable Corfu only for certain modes. See also `global-corfu-modes'.
    ;; :hook ((prog-mode . corfu-mode)
    ;;        (shell-mode . corfu-mode)
    ;;        (eshell-mode . corfu-mode))

    ;; Recommended: Enable Corfu globally.  This is recommended since Dabbrev can
    ;; be used globally (M-/).  See also the customization variable
    ;; `global-corfu-modes' to exclude certain modes.
    :init
    (global-corfu-mode 1)
    (corfu-popupinfo-mode 1)
    (corfu-history-mode 1))


  (use-package corfu-terminal
    :after (corfu)
    :config
    (when (or (daemonp) (not (display-graphic-p)))
      (corfu-terminal-mode)))

  ;; (use-package corfu-mouse
  ;;   :after (corfu)
  ;;   :config 
  ;;   (corfu-mouse-mode)
  ;;   (keymap-set corfu--mouse-ignore-map "<mouse-movement>" 'ignore)
  ;;   (keymap-set corfu-map "<mouse-movement>" 'ignore))

  (use-package kind-icon
    :after (corfu)
    :config
    (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter))



 #+end_src
* keys
#+begin_src emacs-lisp
  (require 'cua-base)

          ;;; Keybinds
  ;; Eat Term
  ;(define-key cua--eat-semi-char-keymap (kbd "C-v") #'eat-yank)
  ;(define-key cua--eat-char-keymap (kbd "C-S-v") #'eat-yank)
  ;(define-key cua--eat-semi-char-keymap (kbd "C-c") #'copy-region-as-kill)
  ;(define-key cua--eat-char-keymap (kbd "C-S-c") #'copy-region-as-kill)
  ;(define-key eat-mode-map (kbd "C-<right>") #'eat-self-input)
  ;(define-key eat-mode-map (kbd "C-<left>") #'eat-self-input)
  ;; perspective
  (define-key global-map (kbd "C-x C-b") #'persp-list-buffers)
  (define-key global-map (kbd "C-x C-B") #'list-buffers)
  (define-key global-map (kbd "C-x b") #'persp-switch-to-buffer*)
  (define-key global-map (kbd "C-x B") #'consult-buffer)
  ;; CUA-like global
  (define-key global-map (kbd "C-s") 'save-buffer)
  (define-key global-map (kbd "C-r") 'query-replace)
  (define-key global-map (kbd "C-S-r") 'replace-string)
  (define-key global-map (kbd "M-r") 'query-replace-regexp)
  (define-key global-map (kbd "M-S-r") 'replace-regexp)
  (define-key global-map (kbd "C-a") 'mark-whole-buffer)
  (define-key global-map (kbd "C-f") 'isearch-forward)
  (define-key global-map (kbd "C-S-f") 'isearch-backward)
  (define-key isearch-mode-map (kbd "C-f") 'isearch-repeat-forward)
  (define-key isearch-mode-map (kbd "C-S-f") 'isearch-repeat-backward)
  (define-key global-map (kbd "M-f") 'consult-ripgrep)
  (define-key global-map (kbd "C-M-f") 'consult-find)
  ;; CUA
  (define-key cua--cua-keys-keymap (kbd "C-z") 'undo-tree-undo)
  (define-key cua--cua-keys-keymap (kbd "C-y") 'undo-tree-redo)
  (define-key cua-global-keymap (kbd "C-SPC") 'completion-at-point)
  (define-key cua-global-keymap (kbd "C-M-SPC") 'cua-set-mark)
  (cua-mode 1)
  ;; TAB
  (define-key global-map (kbd "C-<iso-lefttab>") #'indent-rigidly-left)
  (define-key global-map (kbd "C-<tab>") #'indent-rigidly-right)
  ;; Dashboard
  ;(define-key dashboard-mode-map (kbd "C-r") #'dashboard-refresh-buffer)

  ;; Hyper
  (define-key key-translation-map (kbd "<XF86Calculator>") 'event-apply-hyper-modifier )
  (define-key key-translation-map (kbd "<Calculator>") 'event-apply-hyper-modifier )
  (define-key key-translation-map (kbd "∇") 'event-apply-hyper-modifier )
  ;; Treemacs
  (define-key global-map (kbd "C-H-t") 'treemacs)

  ;; Unbind
  (define-key isearch-mode-map (kbd "C-s") nil)
  (define-key isearch-mode-map (kbd "C-r") nil)
#+end_src

** CUA Overrides

#+begin_src emacs-lisp
  ;; (defun cua--eat-semi-char-override-keymap ()
  ;;   (setq-local cua--keymap-alist (copy-tree cua--keymap-alist))
  ;;   (setf (alist-get 'cua--ena-cua-keys-keymap cua--keymap-alist) cua--eat-semi-char-keymap))
  ;; (defun cua--eat-char-override-keymap ()
  ;;   (setq-local cua--keymap-alist (copy-tree cua--keymap-alist))
  ;;   (setf (alist-get 'cua--ena-cua-keys-keymap cua--keymap-alist) cua--eat-char-keymap))

  ;; (advice-add 'eat-semi-char-mode :after #'cua--eat-semi-char-override-keymap)
  ;; (advice-add 'eat-char-mode :after #'cua--eat-char-override-keymap)
  ;(add-hook 'eat-char-mode-hook #'cua--eat-char-override-keymap)
#+end_src