config.org

# -*- eval: (add-hook 'after-save-hook (lambda () (my/tangle-async)) nil t) -*-
#+property:   header-args :tangle lisp/config.el
#+startup:    overview indent
#+title:        Emacs config
#+options:    \\n:t toc:2
#+category:   configuration
#+parent:     553
#+post_tags:  tools emacs configuration
#+postid:     638
#+date:       [2023-09-29 Fri 23:49]

Available at https://github.com/thatwist/.emacs.d

* * *init & globals*
#+begin_src emacs-lisp
;; -*- lexical-binding: t; -*-
#+end_src
** early-init.el
#+begin_src emacs-lisp :tangle early-init.el
;; -*- lexical-binding: t; -*-
(setq byte-compile-docstring-max-column 250) ;; don't want those wider-then-80 warnings

(if (and (fboundp 'native-comp-available-p)
         (native-comp-available-p))
  (progn
    (message "Native compilation is available")
    (setq native-comp-async-report-warnings-errors nil)
    (setq comp-deferred-compilation t)
    (add-to-list 'native-comp-eln-load-path (expand-file-name "eln-cache/" user-emacs-directory))
    (setq package-native-compile t))
  (message "Native complation is *not* available"))

(push (concat user-emacs-directory "lisp") load-path)
#+end_src

** init.el
#+begin_src emacs-lisp :tangle init.el
;; -*- lexical-binding: t; -*-
(require 'config)

;; native compilation gives only 0.2s init time boost.. nah
;;(load-library "config")
;;(load-file "~/.emacs.d/lisp/config.el")
;;(native-elisp-load (comp-lookup-eln (expand-file-name "lisp/config.el" user-emacs-directory)))

;;(setf native-comp-speed 2 native-comp-debug 0 native-comp-verbose 0 comp-libgccjit-reproducer nil comp-async-compilation t)
;;(setf native-comp-debug 0 native-comp-verbose 0)
;;(native-compile "/home/twist/.config/emacs/lisp/config.el")
;;(native-compile "~/.emacs.d/lisp/config.el")
#+end_src

** messages ts

#+begin_src emacs-lisp
(defun my-message-with-timestamp (old-func fmt-string &rest args)
  "Prepend current timestamp (with microsecond precision) to a message"
  (when fmt-string ;; did this because of some vr/replace empty messages getting into echo area in minibuffer
    (apply old-func
           (concat (format-time-string "[%T.%3N] ")
                   fmt-string)
           args)))

(define-minor-mode message-ts-mode
  "Enable timestamp in messages."
  :lighter "" ;; " T"
  :global t
  (if message-ts-mode
      (advice-add 'message :around #'my-message-with-timestamp)
    (advice-remove 'message #'my-message-with-timestamp)))

(with-eval-after-load 'pretty-hydra
  (pretty-hydra-define+ toggle-hydra nil ("Emacs" (("C-m" message-ts-mode "message-ts-mode" :toggle t)))))
#+end_src

** dependency tree
#+begin_src emacs-lisp
(defvar my/require-tree nil)
(defun require--advice (orig-fun feature &rest args)
  (setq my/require-tree
        (append my/require-tree
                (list (let ((my/require-tree (list feature)))
                        (apply orig-fun feature args)
                        my/require-tree)))))
;; (advice-add 'require :around 'require--advice)
;; (advice-remove 'require 'require--advice)
#+end_src

** package management
*** package.el & load-path
#+name: package.el
#+begin_src emacs-lisp
(setq
  package-archives
  '(("gnu" . "https://elpa.gnu.org/packages/")
    ;;("org" . "https://orgmode.org/elpa/")
    ("nongnu" . "https://elpa.nongnu.org/nongnu/")
    ("melpa" . "https://melpa.org/packages/")
    ("melpa-stable" . "http://stable.melpa.org/packages/")
    )
  package-archive-priorities
  '(
    ("melpa-stable" . 5)
    ("nongnu" . 20)
    ("gnu" . 10)
    ("melpa" . 25))) ;; started using melpa first

(require 'package)

(package-initialize)
#+end_src

#+name: lisp-path
#+begin_src emacs-lisp
(push (concat user-emacs-directory "lisp") load-path)
#+end_src
*** use-package
#+name: use-package
#+begin_src emacs-lisp
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(require 'use-package)

(setq
 ;; Enable ensure by default for use-package
 ;;use-package-always-ensure ;; actually, when using this + ensure-nil, macro still generates code - when using byte-compilation there will be warnings
 use-package-always-defer t
 use-package-compute-statistics t
 ;; use-package-verbose 'debug
 ;; use-package-minimum-reported-time 0 ;; I want to see order and timing
 )

(use-package use-package-ensure-system-package)

(use-package system-packages :ensure)

#+end_src

*** benchmark-init
#+begin_src emacs-lisp
(use-package benchmark-init
  :disabled
  :ensure :demand
  :config
  ;; To disable collection of benchmark data after init is done.
  (add-hook 'after-init-hook 'benchmark-init/deactivate)
  )
#+end_src

*** quelpa
#+begin_src emacs-lisp
(use-package quelpa
  :ensure :demand
  :init
  (setq quelpa-update-melpa-p nil)
  (setq quelpa-checkout-melpa-p nil)
  (setq quelpa-update-melpa-p nil)
  (setq quelpa-update-melpa-p nil)
  (setq quelpa-upgrade-interval 7))

(use-package quelpa-use-package
  :ensure
  :demand
  :init (setq quelpa-use-package-inhibit-loading-quelpa t)
  :config (quelpa-use-package-activate-advice))
#+end_src

*** package menu
#+begin_src emacs-lisp
(use-package paradox
  :ensure)
#+end_src

** startup
#+name: startup
#+begin_src emacs-lisp
(setq is-android (string= "Android" (string-trim (shell-command-to-string "uname -o"))))

(use-package diminish :ensure :demand)

(use-package emacs
  :demand
  :init
  ;; start emacs server
  (require 'server)
  (unless (server-running-p) (server-start))
  :custom
  (inhibit-startup-message t)
  (initial-scratch-message "")
  (initial-buffer-choice nil)
  ;;(initial-major-mode 'fundamental-mode)  ; I don't want to load prog-mode hooks
  :config
  ;; for windows - easier integration with org paths
  (when (eq system-type 'window-nt) (setenv "HOME" "C:\\Users\\Admin"))
  ;; for mac
  ;;(setq mac-option-modifier 'meta)
  ;;(setq mac-command-modifier 'super)
  )
#+end_src

** hydra init
#+begin_src emacs-lisp
(use-package posframe :ensure :defer 0.4)

(use-package hydra :ensure)

(use-package pretty-hydra :ensure :demand)

(use-package hydra-posframe
  ;; :when (display-graphic-p)
  :demand :after (hydra posframe)
  :quelpa (hydra-posframe :fetcher github :repo "Ladicle/hydra-posframe")
  :config
  ;; (when window-system
  ;;   )
  (unless is-android
    (hydra-posframe-mode)
  )
  ;;(setq hydra-hint-display-alist nil)
  )

(use-package major-mode-hydra
  :ensure :demand :after hydra
  :hook (evil-mode . (lambda () (evil-define-key 'motion global-map (kbd "<leader>m") 'major-mode-hydra)))
  :preface
  (defun with-alltheicon (icon str &optional height v-adjust)
    "Displays an icon from all-the-icon."
    (s-concat (all-the-icons-alltheicon icon :v-adjust (or v-adjust 0) :height (or height 1)) " " str))

  (defun with-material (icon str &optional height v-adjust)
    "Displays an icon from material."
    (s-concat (all-the-icons-material icon :v-adjust (or v-adjust 0) :height (or height 1)) " " str))

  (defun with-faicon (icon str &optional height v-adjust)
    "Displays an icon from Font Awesome icon."
    (s-concat (all-the-icons-faicon icon :v-adjust (or v-adjust 0) :height (or height 1)) " " str))

  (defun with-fileicon (icon str &optional height v-adjust)
    "Displays an icon from the Atom File Icons package."
    (s-concat (all-the-icons-fileicon icon :v-adjust (or v-adjust 0) :height (or height 1)) " " str))

  (defun with-octicon (icon str &optional height v-adjust)
    "Displays an icon from the GitHub Octicons."
    (s-concat (all-the-icons-octicon icon :v-adjust (or v-adjust 0) :height (or height 1)) " " str)))

#+end_src

#+RESULTS:

** benchmark&profiling

#+begin_src emacs-lisp
(use-package explain-pause-mode
  :demand
  :quelpa (explain-pause-mode :fetcher github :repo "lastquestion/explain-pause-mode")
  :init
  (pretty-hydra-define+ utils-hydra nil ("Emacs" (("E" explain-pause-top "explain-pause-top"))))
  (pretty-hydra-define+ toggle-hydra nil ("Emacs" (("E" explain-pause-mode "explain-pause(g)" :toggle t))))
  )

(use-package benchmark-init
  :ensure
  ;;:disabled
  ) ;; this package fails to compile
; find bug in init.el
(use-package bug-hunter
  :ensure :disabled)

;(setq
 ;garbage-collection-messages t ; see when gc happens
; gc-cons-threshold #x40000000
; gc-cons-percentage 0.3
;)

(defmacro k-time (&rest body)
  "Measure and return the time it takes evaluating BODY."
  `(let ((time (current-time)))
     ,@body
     (float-time (time-since time))))

; When idle for 15sec run the GC no matter what.
(defvar k-gc-timer
  (run-with-idle-timer 15 t
                       (lambda ()
                         (message "Garbage Collector has run for %.06fsec"
                                  (k-time (garbage-collect))))))

; startup profiler
(use-package esup
  :ensure :commands (esup))

;; esup, didn't work, trying this:
;; workaround chemacs:
;; mv .emacs.d .emacs.d.tmp
;; ln -s .config/emacs .emacs.d
;; emacs -Q -l /home/twist/.config/emacs/lisp/profile-dotemacs.el --eval "(progn (setq user-emacs-directory \"~/.config/emacs/\") (profile-dotemacs))"
;; rm .emacs.d
;; mv .emacs.d.tmp .emacs.d

; startup time
(defun my/display-startup-time ()
  (message "Emacs loaded in %s with %d garbage collections."
           (format "%.2f seconds" (float-time (time-subtract after-init-time before-init-time))) gcs-done))
(add-hook 'emacs-startup-hook #'my/display-startup-time)

(defun byte-recompile-init-file ()
  "Byte-recompile user init files."
  (interactive)
  (byte-recompile-file (concat user-emacs-directory "lisp/config.el"))
  (message (format "byte-compile finished"))
  ;; this doesn't work - subprocess needs correct load-path being populated
  ;; (async-start
  ;;  `(lambda () (require 'bytecomp) (byte-recompile-file ,out-file) ,out-file)
  ;;  `(lambda (result2)
  ;;     (message (format "byte-recompile finished for: %s" result2))))
  )

#+end_src

** safe vars

#+begin_src emacs-lisp
(setq
 safe-local-variable-values
 '(
   (eval add-hook 'after-save-hook (lambda nil (my/tangle-async)) nil t)
   (eval add-hook 'after-save-hook (lambda nil (org-html-export-to-html nil)) t t)
   (eval add-hook 'after-save-hook (lambda nil (my/tangle-async-and-byte-compile-init-file)) nil t)
   (org-archive-location . "~/documents/org/archive/%s_archive.gpg::")
   (org-tags-column . -65)
   (eval setq org-cycle-include-plain-lists 'integrate)
   (eval load-file "ledger-kredo-regex.el.gpg")
   (doom-modeline-buffer-file-name-style . truncate-with-project)
   (doom-modeline-buffer-file-name-style quote truncate-with-project)
   (org-hugo-footer . "

[//]: # \"Exported with love from a post written in Org mode\"
[//]: # \"- https://github.com/kaushalmodi/ox-hugo\"")
   (checkdoc-minor-mode . t)
   (flycheck-disabled-checkers emacs-lisp-checkdoc)
   (eval visual-line-mode t))

                                        ; tramp theme
 custom-safe-themes '("6ebdb33507c7db94b28d7787f802f38ac8d2b8cd08506797b3af6cdfd80632e0" default)
 )
#+end_src

** feature checks

#+begin_src emacs-lisp
(if (functionp 'json-serialize)
  (message "Native JSON is available")
  (message "Native JSON is *not* available"))
#+end_src

** elisp tools
*** debug hooks
this tools for debugging hooks came from here - https://emacs.stackexchange.com/a/19582/29202
#+begin_src emacs-lisp
  (defun my/call-logging-hooks (command &optional verbose)
  "Call COMMAND, reporting every hook run in the process.
Interactively, prompt for a command to execute.

Return a list of the hooks run, in the order they were run.
Interactively, or with optional argument VERBOSE, also print a
message listing the hooks."
  (interactive "CCommand to log hooks: \np")
  (let* ((log     nil)
         (logger (lambda (&rest hooks)
                   (setq log (append log hooks nil)))))
    (my/with-advice
        ((#'run-hooks :before logger))
      (call-interactively command))
    (when verbose
      (message
       (if log "Hooks run during execution of %s:"
         "No hooks run during execution of %s.")
       command)
      (dolist (hook log)
        (message "> %s" hook)))
    log))

(defmacro my/with-advice (adlist &rest body)
  "Execute BODY with temporary advice in ADLIST.

Each element of ADLIST should be a list of the form
  (SYMBOL WHERE FUNCTION [PROPS])
suitable for passing to `advice-add'.  The BODY is wrapped in an
`unwind-protect' form, so the advice will be removed even in the
event of an error or nonlocal exit."
  (declare (debug ((&rest (&rest form)) body))
           (indent 1))
  `(progn
     ,@(mapcar (lambda (adform)
                 (cons 'advice-add adform))
               adlist)
     (unwind-protect (progn ,@body)
       ,@(mapcar (lambda (adform)
                   `(advice-remove ,(car adform) ,(nth 2 adform)))
                 adlist))))
#+end_src

*** eval-after-all

#+begin_src emacs-lisp
(defun eval-after-load-all (my-features form)
  "Run FORM after all MY-FEATURES are loaded.
See `eval-after-load' for the possible formats of FORM."
  (if (null my-features)
      (if (functionp form)
      (funcall form)
    (eval form))
    (eval-after-load (car my-features)
      `(lambda ()
     (eval-after-load-all
      (quote ,(cdr my-features))
      (quote ,form))))))
#+end_src

*** save/read variables into file
#+begin_src emacs-lisp
(defun my/dump-vars-to-file (varlist filename)
  "simplistic dumping of variables in VARLIST to a file FILENAME"
  (save-excursion
    (let ((buf (find-file-noselect filename)))
      (set-buffer buf)
      (erase-buffer)
      (my/dump-vars varlist buf)
      (save-buffer)
      (kill-buffer))))

(defun my/dump-vars (varlist buffer)
  "insert into buffer the setq statement to recreate the variables in VARLIST"
  (cl-loop for var in varlist do
           (print (list 'setq var (list 'quote (symbol-value var)))
                  buffer)))
#+end_src

*** eldoc
#+begin_src emacs-lisp
(use-package eldoc :ensure
  :custom
  (eldoc-echo-area-prefer-doc-buffer nil)
  (eldoc-echo-area-use-multiline-p t)
  (eldoc-echo-area-display-truncation-message t)
  :config (diminish 'eldoc-mode ""))

(use-package eldoc-box :ensure
  ;; todo - local-keymap remap <leader>hh                            (ref:eldoc-box-help-bind)
  ;; :config (general-def '(normal motion) 'eglot--managed-mode-map [remap helpful-at-point] 'eldoc-box-help-at-point)
  ;; :hook (eglot-managed-mode . eldoc-box-hover-at-point-mode)
  )

(defun my/add-docstring-to-eldoc (ret &rest args)
  "Add the first line of the docstring to ElDoc info."
  (when ret
    (let* ((doc (elisp--docstring-first-line (documentation (car args) t)))
           (w (frame-width))
           (color-doc (propertize doc 'face 'font-lock-comment-face)))
      (when (and doc (not (string= doc "")))
        (setq ret (concat ret " " color-doc))
        (when (> (length doc) w)
          (setq ret (substring ret 0 (1- w))))))
    ret))

(with-eval-after-load 'emacs-lisp-mode
  (advice-add 'elisp-get-fnsym-args-string :filter-return #'my/add-docstring-to-eldoc))
#+end_src

*** other tools
#+begin_src emacs-lisp
;; why isn't it a part of standart lib
(defun delete-from-alist-by-key (list-var elem)
  "Interactively remove element from alist."
  (interactive
   (let ((var (helpful--read-symbol
               "Variable: "
               (helpful--variable-at-point)
               #'(lambda (symb) (and (boundp symb) (listp (symbol-value symb)) (helpful--variable-p symb))))))
     (list var 
           (completing-read "Choose element to delete from: " (symbol-value var) nil t))))
  (message "deleting %s from %s=%s" elem list-var (symbol-value list-var))
  (set list-var (assoc-delete-all elem (symbol-value list-var))))
#+end_src

* * *input & security
** input & langs

#+begin_src emacs-lisp
;; input method
(setq default-input-method "ukrainian-computer")

;; free binding for iedit
(customize-set-variable 'flyspell-auto-correct-binding [(meta control ?\;)])

(customize-set-variable 'flyspell-mode-line-string " FS")

;; turn it manually on demand
;;(add-hook 'text-mode-hook #'flyspell-mode)

(when (eq system-type 'windows-nt)
  (with-eval-after-load "ispell"
    (setq ispell-dictionary "en_US")
    (setq ispell-hunspell-dictionary-alist
          '(
            ("en_US" "[[:alpha:]]" "[^[:alpha:]]" "[']" t ("-d" "en_US") nil utf-8)
            ;; TODO - doesn't work
            ;;(setenv "LANG" "en_US.UTF-8")
            ;;(setq ispell-dictionary "uk_UA,en_US")
            ;;(setq ispell-hunspell-dictionary-alist '(("en_US" "[[:alpha:]]" "[^[:alpha:]]" "[']" t ("-d" "en_US") nil utf-8)
            ;;                                         ("uk_UA" "[[:alpha:]]" "[^[:alpha:]]" "[']" t ("-d" "uk_UA") nil utf-8)
            ;;                                         ))
            ;;(ispell-set-spellchecker-params)
            ;;(ispell-hunspell-add-multi-dic "uk_UA,en_US")
            ))))

;(set-language-environment "UTF-8")
(set-default-coding-systems 'utf-8)
#+end_src

** clipboard

#+begin_src emacs-lisp
;; clipboard share with x11
(use-package xclip
  :ensure
  :if window-system
  :unless (eq system-type 'windows-nt)
  :defer 1
  :config (xclip-mode 1))
#+end_src

** sessions

#+begin_src emacs-lisp
(use-package desktop
  ;; :init (desktop-save-mode 1)
  :custom
  ((desktop-modes-not-to-save '(tags-table-mode org-mode helpful-mode))
   ;;(desktop-files-not-to-save "\\(\\`/[^/:]*:\\|(ftp)\\|(\\.gz)\\'\\)")
   (desktop-files-not-to-save ".*")
   (desktop-load-locked-desktop t) ; do not ask that lock-file exists, this fixes the issue with daemon wait answer
   (desktop-buffers-not-to-save ".*")) ;; actually, I dont' want it to save any buffers
  )

(use-package super-save
  :ensure
  :diminish
  :defer 1.1
  :config
  ;; add integration with ace-window
  ;;(add-to-list 'super-save-triggers 'ace-window)
  (add-to-list 'super-save-triggers 'ivy-switch-buffer)
  (add-to-list 'super-save-triggers 'tab-line-switch-to-next-tab)
  (add-to-list 'super-save-triggers 'tab-line-switch-to-prev-tab)
  (add-to-list 'super-save-triggers 'tab-line-next-tab-cycle)
  (add-to-list 'super-save-triggers 'tab-line-prev-tab-cycle)
  ;; save on find-file
  (add-to-list 'super-save-hook-triggers 'find-file-hook)
  ;; after list change
  (super-save-mode +1)
  :custom
  ;; these are actually global configs, but I keep them under super-save
  (backup-directory-alist `(("." . ,(expand-file-name (concat user-emacs-directory "backups")))))
  (auto-save-file-name-transforms `((".*" ,(concat user-emacs-directory "auto-save/") t)))
  (super-save-idle-duration 20)
  (super-save-auto-save-when-idle t))

(use-package savehist
  :ensure
  :defer 1
  :config
  (savehist-mode)
  (add-to-list 'savehist-additional-variables 'search-ring)
  (add-to-list 'savehist-additional-variables 'regexp-search-ring)
  )
#+end_src

** accessibility

#+begin_src emacs-lisp
;(load-file "/usr/share/festival/festival.el")
;(autoload 'say-minor-mode "festival" "Menu for using Festival." t)
;(say-minor-mode t)

#+end_src

** security & encryption

#+begin_src emacs-lisp
;;(add-hook 'after-init-hook
;;          #'(lambda()
;;              (require 'epa-file)
;;              (epa-file-enable)))
;;(use-package epa
;;  :defer t
;;  :custom
;;  (epg-gpg-program "gpg")
;;  (epa-pinentry-mode nil))
(use-package epg
  :config
  (setq epg-pinentry-mode 'loopback))

;; used for prompts on gpg - if pinentry program = emacs
(use-package pinentry
  :ensure)
;; This should force Emacs to use its own internal password prompt instead of an external pin entry program
(setenv "GPG_AGENT_INFO" nil)

;; password store
(use-package password-store
  :ensure
  :config
  (when (eq system-type 'windows-nt)
    (setq password-store-executable (executable-find "pass.bat"))))

(use-package pass
  :ensure)

(use-package auth-source-pass
  :disabled
  :demand :after auth-source
  :config (auth-source-pass-enable)
  )
;; was used until auth-source-pass came
;;(setq auth-sources '("~/.authinfo.gpg" "~/.netrc"))

;; when preserving emacs buffers between sessions,
;; close buffers which may ask for user input (decryption password)
;; on the next startup and would prevent emacs-server to start in backgroud
(add-hook 'kill-emacs-hook (lambda()
                             (save-some-buffers t)
                             (kill-matching-buffers ".*.gpg" nil t)
                             (kill-matching-buffers "ejc-sql-editor" nil t) ;; this may ask for authinfo on next load
                             ))
#+end_src

** edit-server

#+begin_src emacs-lisp
;; edit server for chrome plugin
(use-package edit-server
  :disabled
  :ensure
  :commands edit-server-start
  ;;:init
  ;;          (add-hook 'after-init-hook
  ;;                    #'(lambda() (edit-server-start))))
  :config (setq edit-server-new-frame-alist
                '((name . "Edit with Emacs FRAME")
                  (top . 200)
                  (left . 200)
                  (width . 80)
                  (height . 25)
                  (minibuffer . t)
                  (menu-bar-lines . t)
                  (window-system . x))))
#+end_src
* * *ui & themes*
** display profile
#+begin_src emacs-lisp
  (defun load-display-profile ()
    "Load the current display profile settings."
    (interactive)
    (let ((profile-file (expand-file-name "lisp/display-profile.el"
  user-emacs-directory)))
      (if (file-exists-p profile-file)
          (progn
            (load-file profile-file)
            ;; (message "Display profile loaded from %s" profile-file)
            )
        (message "Display profile file not found: %s" profile-file))))
#+end_src
** fonts
#+name: fonts
#+begin_src emacs-lisp

  ;; set default
  ;; (if (eq system-type 'windows-nt)
  ;;     (set-face-attribute 'default nil :font "Fira Mono" :height 130) ;; defaults to 139
  ;;   ;;(set-face-attribute 'default nil :font "Input Mono Narrow" :height 120)
  ;;   ;; (set-face-attribute 'default nil :font "Fira Code" :height 140)
  ;;   (set-face-attribute 'default nil :font "Input Mono Narrow" :height 170)
  ;;   )
  
  ;; todo: org this and lisp/display-profile.el
  ;; (set-face-attribute 'default nil :font "0xProto" :height 98)
  ;; (set-face-attribute 'default nil :font "Source Code Pro Medium" :height 98)
  ;; (set-face-attribute 'default nil :font "IBM Plex Mono Text" :height 98)
  (set-face-attribute 'default nil :font "Input Mono Narrow" :height 100)
  ;; WIP - have no idea how emacs handles font aliasing/hinting
  ;; (set-frame-font "InputMonoNarrow-10:antialias=none:hinting=true:hintstyle=hintfull:autohint=false" t t)
  ;; (set-frame-font "InputMonoNarrow-10:antialias=none:hinting=true:hintstyle=hintfull:autohint=true" t t)
  ;; (set-frame-font "InputMonoNarrow-10:antialias=none:hinting=true" t t)

  ;; setting explicit fallback to icon font, otherwise IBMPlexSansTC is picked up (should probably remove that font)
  ;; can put (font-spec :size 50 :name "Miriam Mono CLM:bold") instead of "Miriam Mono CLM:bold"
  (set-fontset-font "fontset-default" '(#xE000 . #xF8FF) "Symbols Nerd Font")
  ;; default fallback, probably fixes some more on top of the above fallback
  (set-fontset-font t nil "Symbols Nerd Font" nil 'append)
  (custom-theme-set-faces
   'user
   ;; '(variable-pitch ((t (:family "Arial" :height 115))))
   ;; '(variable-pitch ((t (:family "IBM Plex Sans" :height 115))))
   ;; '(variable-pitch ((t (:family "Verdana" :height 105))))
   ;; '(variable-pitch ((t (:family "DejaVu Sans" :height 105))))
   '(variable-pitch ((t (:family "Input Sans Narrow" :height 100))))
   ;; '(variable-pitch ((t (:family "Input Sans Narrow" :height 100))))
   ;; '(variable-pitch ((t (:family "Input Serif" :height 102))))
   ;; '(variable-pitch ((t (:family "Input Serif Narrow" :height 102))))
   ;; '(variable-pitch ((t (:family "IBM Plex Serif" :height 102))))
   ;; '(variable-pitch ((t (:family "IBM Plex Sans" :height 102))))
   ;; '(variable-pitch ((t (:family "Georgia" :height 110))))
   '(fixed-pitch ((t ( :family "0xProto" :height 98))))
   ;; '(fixed-pitch ((t ( :family "Input Mono" :height 98))))
   )

  ;; this one basically overrides above but I keep above for easy experiments with fonts
  (load-display-profile)

  ;; (if (eq system-type 'windows-nt)
  ;;     (set-face-attribute 'default nil :font "Fira Mono" :height 114) ;; defaults to 139
  ;;   (set-face-attribute 'default nil :font "Fira Mono" :height 114) ;; defaults to 139
  ;;   ;; 
  ;;   ;;(set-face-attribute 'default nil :font "Source Code Pro-11")
  ;;   ;; equivalent
  ;;   ;;(add-to-list 'default-frame-alist '(font . "Input Mono Narrow-9"))
  ;;   ;;(add-to-list 'default-frame-alist '(font . "Source Code Pro-10"))
  ;;   )

  ;;(set-face-attribute 'bold nil :height 95) ;; good way to emphasize

  ;;(set-face-attribute 'default nil :font "Input Mono Narrow" :height 95)
  ;;(set-face-attribute 'default nil :font "Source Code Pro" :height 150) ;; defaults to 139
  ;;(set-face-attribute 'default nil :font "Source Code Pro Medium")
  ;; equivalent of
  ;;(set-frame-font "Source Code Pro Medium" nil t)

  ;; or use M-x menu-set-font, or use M-x set-frame-font

  ;; testing
  ;;(set-fontset-font t 'latin "Noto Sans")

  ;; something for icons?
  (setq inhibit-compacting-font-caches t)
#+end_src

** frame alpha
#+begin_src emacs-lisp
(if (eq system-type 'windows-nt)
    (add-to-list 'default-frame-alist '(alpha . (98 . 98)))
  (add-to-list 'default-frame-alist '(alpha . (100 . 100))))

(defun frame-update-alpha (updfunc)
  "Apply a given function to existing alpha parameter of the selected frame.
UPDFUNC function which accepts current alpha and returns new"
  (when (functionp updfunc)
    (let* ((current-alpha (car (frame-parameter nil 'alpha)))
           (new-alpha (funcall updfunc current-alpha))
           (new-alpha (min 100 (max 0 new-alpha))))
    (set-frame-parameter (selected-frame) 'alpha (list new-alpha new-alpha)))))

(defun frame-incr-alpha ()
  "Increment existing frame alpha by 3."
  (interactive)
  (frame-update-alpha (lambda (alpha) (+ alpha 3))))

(defun frame-decr-alpha ()
  "Decrement existing frame alpha by 3."
  (interactive)
  (frame-update-alpha (lambda (alpha) (- alpha 3))))
#+end_src

** icons

#+begin_src emacs-lisp
(use-package all-the-icons :ensure :demand)

(use-package fontawesome :ensure)

(use-package nerd-icons :ensure :demand)

;; bad with hidpi - icons modeline
;;(use-package mode-icons :config (mode-icons-mode -1))

;; in terminal (but it actually doesn't work for doom-modeline)
;; this messes up symbols actually, e.g.  0xEACE is onion while it has to be database symbol, and it is 8years old font btw
;; (use-package icons-in-terminal
;;   :quelpa (icons-in-terminal :fetcher github :repo "seagle0128/icons-in-terminal.el")
;;   )

(use-package nerd-icons-completion
  :ensure
  :after nerd-icons)
#+end_src

** modeline
*** doom-modeline
#+name: doom-modeline
#+begin_src emacs-lisp
;; (nerd-icons-install-fonts)
(use-package doom-modeline
  :ensure
  ;; :defer 0.1
  :disabled
  :config
  (doom-modeline-mode)
  :custom
  ((column-number-mode t)
   ;; these will hardcode height and zoom-frm will not work for mode-line
   ;;(set-face-attribute 'mode-line nil :height 90)
   ;;(set-face-attribute 'mode-line-inactive nil :height 50)
   (doom-modeline-height 25)
   (doom-modeline-bar-width 6)
   (doom-modeline-workspace-name nil) ;; tab-bar-mode displays this in the top
   (doom-modeline-indent-info t)
   (doom-modeline-window-width-limit 140) ; works for:
                                        ;(window-font-width nil 'mode-line) ; 20
                                        ;(window-font-height nil 'mode-line) ; 42
   ;; scala projects may have very long file paths, in that case doommodeline doesn't truncate it
   ;;:custom (doom-modeline-buffer-file-name-style 'truncate-with-project)
   (doom-modeline-minor-modes t)
   (doom-modeline-modal-icon t) ;; its better with nerd-icons now
   (doom-modeline-major-mode-icon t)
   (doom-modeline-buffer-state-icon t)
   ))

;; nice
(use-package minions
  :ensure
  :defer 1
  :config (global-set-key [S-down-mouse-3] 'minions-minor-modes-menu))
#+end_src
*** mood-line
#+begin_src emacs-lisp
(use-package mood-line
  :ensure
  :disabled
  ;; Enable mood-line
  :config
  (mood-line-mode)
  ;; Use pretty Fira Code-compatible glyphs
  ;; Default format:
  ;;   * init.el  4:32 Top                                         ELisp  ! Issues: 2
  ;; (setq mood-line-format mood-line-format-default)

  ;; Extended format:
  ;;   * init.el  4:32:52 Top                    SPCx2  LF  UTF-8  ELisp  ! Issues: 2
  (setq mood-line-format mood-line-format-default-extended)

  ;; Custom format:
  ;;   * init.el : ELisp                                     Top 4:32  |  ! Issues: 2
  ;; (setq mood-line-format
  ;;       (mood-line-defformat
  ;;        :left
  ;;        (((mood-line-segment-buffer-status) . " ")
  ;;         ((mood-line-segment-buffer-name)   . " : ")
  ;;         (mood-line-segment-major-mode))
  ;;        :right
  ;;        (((mood-line-segment-scroll)             . " ")
  ;;         ((mood-line-segment-cursor-position)    . "  ")
  ;;         ((when (mood-line-segment-checker) "|") . "  ")
  ;;         ((mood-line-segment-checker)            . "  "))))

  ;; The default set of glyphs:
  ;;   * myModifiedFile.js  Replace*3                 + main  JavaScript  ! Issues: 2
  ;;(setq mood-line-glyph-alist mood-line-glyphs-ascii)

  ;; A set of Fira Code-compatible Unicode glyphs:
  ;;   ● myModifiedFile.js  Replace×3                 + main  JavaScript  → Issues: 2
  ;; (setq mood-line-glyph-alist mood-line-glyphs-fira-code)

  ;; A set of Unicode glyphs:
  ;;   ● myModifiedFile.js  Replace✕3                 🞤 main  JavaScript  ⚑ Issues: 2
  (setq mood-line-glyph-alist mood-line-glyphs-unicode)

  ;; :custom
  ;;(mood-line-glyph-alist mood-line-glyphs-fira-code)
  )

#+end_src
*** telephone-line
#+name: telephone-line
#+begin_src emacs-lisp
(use-package telephone-line
  :ensure
  :demand
  :pin melpa
  :custom-face
  ;; (telephone-line-evil-normal ((t (:background "olive drab" :inherit telephone-line-evil))))
  ;; (telephone-line-evil-insert ((t (:background "indian red" :inherit telephone-line-evil))))
  ;; (telephone-line-evil-visual ((t (:background "dark goldenrod" :inherit telephone-line-evil))))
  ;; (telephone-line-evil-operator ((t (:background "orchid4" :inherit telephone-line-evil))))
  ;; (telephone-line-evil-motion ((t (:background "royal blue" :inherit telephone-line-evil))))
  ;; (mode-line ((t (:background "#564c44" :foreground "#faeac9" ))))
  ;; (header-line ((t (:underline (:color "#c2b491" :style line :position t) :overline "#c2b491" :box nil :inverse-video
  ;;                              nil :foreground "#fdeed3" :background "#564c44" :stipple nil :extend nil :inherit nil))))
  ;; light paper theme
  (telephone-line-evil-normal ((t (:foreground "#363c34" :background "#cef4aa" :inherit telephone-line-evil))))
  (telephone-line-evil-insert ((t (:foreground "#363c34" :background "#f3caf8" :inherit telephone-line-evil))))
  
  (telephone-line-evil-replace ((t (:foreground "#363c34" :background "#cefefe" :inherit telephone-line-evil))))
  (telephone-line-evil-emacs ((t (:foreground "#363c34" :background "#caaafa" :inherit telephone-line-evil))))
  (telephone-line-evil-operator ((t (:foreground "#363c34" :background "#f8e303" :inherit telephone-line-evil))))
  (telephone-line-evil-motion ((t (:foreground "#363c34" :background "#add8e6" :inherit telephone-line-evil))))
  (telephone-line-accent-active ((t (:foreground "#363c34" :background "#ffdfb1" :inherit telephone-line-evil))))
  (telephone-line-accent-inactive ((t (:foreground "#363c34" :background "#e0caa8" :inherit telephone-line-evil))))
  (mode-line ((t (:foreground "#363c34" :background "#fdfae8" ))))
  (header-line ((t (:underline (:color "#c2b491" :style line :position t) :overline "#c2b491" :box nil :inverse-video
                               nil :background "#fdfae8" :foreground "#363c34" :stipple nil :extend nil :inherit nil))))
  :custom
  (telephone-line-target 'mode-line;; header-line
                         )
  (telephone-line-lhs
   '((evil   . (telephone-line-evil-tag-segment))
     ;; (modal  . (telephone-line-meow-tag-segment))
     (accent . (telephone-line-vc-segment
                ;; telephone-line-erc-modified-channels-segment
                telephone-line-process-segment))
     (nil . (
             ;; telephone-line-position-segment
             telephone-line-airline-position-segment
             ;; (telephone-line-raw mode-line-frame-identification t)
             ))
     ;; (nil    . (
     ;;            ;; I'm actually see buffer name  in tab-line
     ;;            ;; telephone-line-projectile-segment
     ;;            ;; telephone-line-projectile-buffer-segment
     ;;            ;; telephone-line-project-buffer-segment
     ;;            ;; telephone-line-buffer-segment
     ;;            ))
     ))
  (telephone-line-rhs
   '((nil . (
             ;; telephone-line-flycheck-segment
             telephone-line-custom-flycheck-segment 
             ;; telephone-line-flymake-segment
             telephone-line-input-info-segment
             telephone-line-misc-info-segment
             ;; telephone-line-hud-segment
             ))
     (accent (
              telephone-line-pyenv-segment
              ;; pyvenv is handled by misc-info
              ;; telephone-line-venv-segment
              ;; telephone-line-micromamba-segment
              ;;telephone-line-major-mode-segment
              ))
     (accent (telephone-line-lsp-segment
              ;;telephone-line-major-mode-segment
              ))
     (evil (telephone-line-major-mode-segment
            ;;telephone-line-airline-position-segment
            ))
     ))
  (telephone-line-faces
   '((evil . telephone-line-modal-face)
     (modal . telephone-line-modal-face)
     ;; (modal . telephone-line-meow-face)
     (accent . (telephone-line-accent-active . telephone-line-accent-inactive))
     (nil . (mode-line . mode-line-inactive))))
  :config
  (column-number-mode)
  (defun telephone-line-meow-face (active)
    (cond ((not active) 'mode-line-inactive)
          ((and meow-normal-mode (region-active-p)) 'telephone-line-evil-visual)
          (meow-normal-mode 'telephone-line-evil-normal)
          (meow-insert-mode 'telephone-line-evil-insert)
          (meow-motion-mode 'telephone-line-evil-emacs)
          (meow-keypad-mode 'telephone-line-evil-operator)
          (meow-beacon-mode 'telephone-line-evil-replace)))
  (telephone-line-defsegment telephone-line-micromamba-segment ()
    (when (and (boundp 'micromamba-env-current-prefix) micromamba-env-current-prefix)
      (car (last (split-string micromamba-env-current-prefix "/")))))
  (telephone-line-defsegment telephone-line-venv-segment ()
    (when (and (boundp 'pyvenv-virtual-env) pyvenv-virtual-env)
      pyvenv-virtual-env-name
      ;; (car (last (butlast (split-string pyvenv-virtual-env "/") 1)))
      ))
  (telephone-line-defsegment telephone-line-pyenv-segment ()
    (when (getenv "PYENV_VERSION") (getenv "PYENV_VERSION")))
  (telephone-line-defsegment telephone-line-lsp-segment ()
    (when (fboundp 'lsp--workspace-print)
      (mapconcat
       (lambda (workspace)
         (car (split-string (lsp--workspace-print workspace) ":")))
       lsp--buffer-workspaces ",")))
  ;; (telephone-line-raw vc-mode t)
  (setq-default mode-line-format nil) 
  (setq-default
   mode-line-buffer-identification
   '((:eval
      (list
       (propertize
        (if buffer-file-name
            (let* ((file-path
                    (abbreviate-file-name (expand-file-name (buffer-file-name))))
                   (file-path-length (length file-path))
                   (file-path-max-length 55))
              (if (> file-path-length file-path-max-length)
                  (concat "…" (truncate-string-to-width
                               file-path file-path-length
                               (- file-path-length file-path-max-length)
                               ;;" " "…"
                               ))
                file-path))
          (buffer-name))
        'face 'font-lock-string-face)))))
  (telephone-line-defsegment telephone-line-custom-flycheck-segment ()
    "Displays current checker state."
    (when (bound-and-true-p flycheck-mode)
      (let* ((text (pcase flycheck-last-status-change
                     ('finished (if flycheck-current-errors
                                    (let-alist (flycheck-count-errors flycheck-current-errors)
                                      (if (or .error .warning)
                                          (propertize (format "%s/%s"
                                                              (or .error 0) (or .warning 0))
                                                      'face 'telephone-line-warning)
                                        ""))
                                  (propertize ":)" 'face 'telephone-line-unimportant)))
                     ('running     "*")
                     ('no-checker  (propertize "-" 'face 'telephone-line-unimportant))
                     ('not-checked "=")
                     ('errored     (propertize "!" 'face 'telephone-line-error))
                     ('interrupted (propertize "." 'face 'telephone-line-error))
                     ('suspicious  "?"))))
        (propertize text
                    'help-echo (pcase flycheck-last-status-change
                                 ('finished "Display errors")
                                 ('running "Running...")
                                 ('no-checker "No Checker")
                                 ('not-checked "Not Checked")
                                 ('errored "Error!")
                                 ('interrupted "Interrupted")
                                 ('suspicious "Suspicious?"))
                    'display '(raise 0.0)
                    'mouse-face '(:box 1)
                    'local-map (make-mode-line-mouse-map
                                'mouse-1 #'flycheck-list-errors)))))
  (display-battery-mode -1)
  (display-time-mode -1)
  (telephone-line-mode 1)
  )

#+end_src
** minibuffer & miniwindows & echo area
#+begin_src emacs-lisp
(use-package window
  ;;https://www.gnu.org/software/emacs/manual/html_node/elisp/Echo-Area-Customization.html
  :custom
  ;; (cursor-in-echo-area t) ;; if t then it disables on-hover msgs in echo for some reason
  (max-mini-window-height 0.3)
  (resize-mini-windows 'grow-only)
  ;;(resize-mini-frames t)
  (echo-keystrokes 0.2)
  (enable-recursive-minibuffers t) ;; :EXPERIMENTAL: - minibuffer within minibuffer
  )
#+end_src

** themes
#+name: gruvbox
#+begin_src emacs-lisp
(use-package grey-paper-theme
  :ensure t
  ;;:disabled
  :config
  (load-theme 'grey-paper t)
  ;; (custom-set-faces
  ;;  `(tab-line-tab-inactive ((t (:background ,gruvbox-bg :foreground ,gruvbox-light0))))
  ;;  `(tab-line-tab ((t (:background ,gruvbox-dark2 :foreground ,gruvbox-light0))))
  ;;  `(tab-line ((t (:background ,gruvbox-bg :foreground ,gruvbox-light0))))
  ;;  `(tab-line-highlight ((t (:inherit (tab-line-tab))))) ;; mouseover
  ;;  `(tab-line-tab-current ((t (:extend t :background ,gruvbox-dark2 :foreground ,gruvbox-light0 :weight bold
  ;;                                      ;;:underline t
  ;;                                      ;;:box '(:line-width (1 . 1) :style released-button)
  ;;                                      )))))
  )

(use-package paper-theme
  :ensure t
  ;;:config (load-theme 'paper t)
  )

(use-package gruvbox-theme
  :ensure
  :defer 0.1
  :disabled
  :init
  (defvar my/toggle-dark t)
  (defun my/tab-line--set-faces ()
    (custom-set-faces
     `(tab-line-tab-inactive ((t (:background ,gruvbox-bg :foreground ,gruvbox-light0))))
     `(tab-line-tab ((t (:background ,gruvbox-dark2 :foreground ,gruvbox-light0))))
     `(tab-line ((t (:background ,gruvbox-bg :foreground ,gruvbox-light0))))
     `(tab-line-highlight ((t (:inherit (tab-line-tab))))) ;; mouseover
     `(tab-line-tab-current ((t (:extend t :background ,gruvbox-dark2 :foreground ,gruvbox-light0 :weight bold
                                         ;;:underline t
                                         ;;:box '(:line-width (1 . 1) :style released-button)
                                         ))))))
  (defun my/load-dark-theme ()
    (mapc #'disable-theme custom-enabled-themes)
    (load-theme 'gruvbox-dark-hard t)
    ;; can't find a way to get those colors from the theme def itself
    (let* ((gruvbox-dark0_hard "#1d2021")
           (gruvbox-dark2 "#504945")
           (gruvbox-light0 "#fdf4c1")
           (gruvbox-bg gruvbox-dark0_hard))
      (my/tab-line--set-faces)))
  (defun my/load-light-theme ()
    (mapc #'disable-theme custom-enabled-themes)
    (load-theme 'gruvbox-light-soft t)
    (let* ((gruvbox-dark0_soft "#f2e5bc")
           (gruvbox-dark2 "#d5c4a1")
           (gruvbox-light0 "#282828")
           (gruvbox-bg gruvbox-dark0_soft))
      (my/tab-line--set-faces)))
  (defun my/toggle-light-dark ()
    (interactive)
    (if (eq (car custom-enabled-themes) 'gruvbox-light-soft)
        (progn (my/load-dark-theme) (setq my/toggle-dark t))
      (progn (my/load-light-theme) (setq my/toggle-dark nil))))
  :config
  ;;(load-theme 'gruvbox-dark-medium t)
  (my/load-dark-theme)
  )

(use-package doom-themes
  :ensure
  :init
  (defun my/restore-mode-line ()
    "Restore modeline after doom-themes ding, sometimes it gets stuck into doom-modeline-error state"
    (interactive)
    (setq face-remapping-alist (delete (assq 'mode-line face-remapping-alist) face-remapping-alist)))
  :defer 0.1
  :config
  ;(load-theme 'doom-one t)
  ;(load-theme 'doom-gruvbox t)
  (doom-themes-visual-bell-config)
  ;(doom-themes-neotree-config)
  ;(doom-themes-treemacs-config)
  (doom-themes-org-config)
  :custom
  (doom-themes-enable-bold t)
  (doom-themes-enable-italic t))
#+end_src

** theme auto changers

#+begin_src emacs-lisp
;; todo - doesn't work
;; (use-package theme-changer
;;   :config
;;   (setq calendar-location-name "Dallas, TX")
;;   (setq calendar-latitude 32.85)
;;   (setq calendar-longitude -96.85)
;;   (change-theme nil 'dracula-theme)
;; )

;(use-package modus-operandi-theme)
;(use-package modus-vivendi-theme)
;; Define coordinates
;(setq calendar-latitude 49.784443
;      calendar-longitude 24.056473)
;; Light at sunrise
;(load-theme 'modus-operandi t t)
;(run-at-time (nth 1 (split-string (sunrise-sunset)))
;             (* 60 60 24)
;             (lambda ()
;               (enable-theme 'modus-operandi)))
;;; Dark at sunset
;(load-theme 'modus-vivendi t t)
;(run-at-time (nth 4 (split-string (sunrise-sunset)))
;             (* 60 60 24)
;             (lambda ()
;               (enable-theme 'modus-vivendi)))
#+end_src

** other faces
#+begin_src emacs-lisp
;; trying to use light themes
;; (custom-set-faces '(region ((t (:extend t :background "dark slate blue")))))
(custom-set-faces '(fringe ((t (:weight bold :height 1.2 :width expanded)))))
;; (custom-set-faces '(default ((t (:foreground "#e7e3c9")))))
(custom-set-faces '(default ((t (:background "#ffffff" :foreground "#020507")))))
(custom-set-faces '(highlight ((t (:background "#efeaf9"))))) ;; used by hl-line-mode ;; #f8f7ef
(custom-set-faces '(region ((t (:background "#e1e0f7" :inverse-video t)))))
(set-face-foreground 'window-divider "#777")
(setq window-divider-default-right-width 2)
(window-divider-mode)
(custom-set-faces '(error ((t (:foreground "#ef0204")))))
(custom-set-faces '(isearch ((t (:foreground "#cfefff" :background "#9c6acc")))))
(custom-set-faces '(sh-quoted-exec ((t (:foreground "#9f0204")))))
(custom-set-faces '(sh-heredoc ((t (:foreground "#6f9244")))))
(custom-set-faces '(markdown-code-face ((t (:background "#e7e3b9")))))
(custom-set-faces '(markdown-inline-code-face ((t (:foreground "#126824" :background "#e7e3b9")))))
(custom-set-faces '(markdown-table-face ((t (:background "#e7e3b9")))))
(custom-set-faces '(markdown-pre-face ((t (:background "#e7e3b9")))))
(custom-set-faces '(markdown-markup-face ((t (:background "#e7e3b9")))))
(custom-set-faces '(markdown-language-keyword-face ((t (:background "#e7e3b9")))))
(custom-set-faces '(diredfl-symlink ((t (:foreground "#56a510")))))
(custom-set-faces '(diredfl-compressed-file-suffix ((t (:foreground "#0cb9ff")))))
(custom-set-faces '(diredfl-dir-name ((t (:foreground "#8b0000")))))
(custom-set-faces '(dired-subtree-depth-1-face ((t (:background "#f5f5f5")))))
(custom-set-faces '(dired-subtree-depth-2-face ((t (:background "#f0f0f0")))))
(custom-set-faces '(dired-subtree-depth-3-face ((t (:background "#eaeaea")))))
(custom-set-faces '(dired-subtree-depth-4-face ((t (:background "#e5e5e5")))))
(custom-set-faces '(dired-subtree-depth-5-face ((t (:background "#e0e0e0")))))
(custom-set-faces '(dired-subtree-depth-6-face ((t (:background "#dadada")))))
(custom-set-faces '(dired-subtree-depth-7-face ((t (:background "#d5d5d5")))))
(custom-set-faces '(dired-subtree-depth-8-face ((t (:background "#d0d0d0")))))
(custom-set-faces '(dired-subtree-depth-9-face ((t (:background "#cbcbcb")))))
(custom-set-faces '(dired-subtree-depth-10-face ((t (:background "#c8c8c8")))))
(setq use-system-tooltips nil)
(setq tooltip-reuse-hidden-frame t)
(custom-set-faces '(tooltip
                    ((t (
                         :family "Source Code Pro"
                         :weight semi-bold :slant oblique
                         :height 140
                         :box nil
                         :foreground "#101823"
                         :background "#ffffff")))))
;; trying colorize echo area
;; (custom-set-faces '(minibuffer-prompt ((t (:background "#fdfae8")))))
(defun my-minibuffer-setup-hook ()
  (with-current-buffer (get-buffer " *Echo Area 0*")
    (face-remap-add-relative 'default '(:background "#fdfae8")))
  (with-current-buffer (get-buffer " *Echo Area 1*")
    (face-remap-add-relative 'default '(:background "#fdfae8"))
    ;; (setq-local face-remapping-alist '((default (:background "#fdfaf8"))))
    )
  )
(add-hook 'minibuffer-setup-hook 'my-minibuffer-setup-hook)

(custom-set-faces '(font-lock-keyword-face ((t :family "Source Code Pro"
                                               :weight bold :slant oblique))))
(custom-set-faces '(mode-line ((t 
                                :foreground "#363c34"
                                :background "#fdfae8"
                                :box (:line-width -1 :style pressed-button)
                                ))))
(custom-set-faces '(font-lock-type-face
                    ((t :family "Source Code Pro"
                        :background "#fde"
                        :slant oblique))))
(custom-set-faces '(font-lock-string-face ((t :family "Source Code Pro" :foreground "#777"))))
(custom-set-faces '(font-lock-constant-face ((t :family "Source Code Pro" :background "#e8eaf8"))))

(custom-set-faces '(font-lock-builtin-face ((t (:box t)))))
(custom-set-faces '(font-lock-number-face ((t (:foreground "#50cbab")))))
(custom-set-faces '(font-lock-doc-face ((t (:slant italic :family "Source Code Pro" :foreground "#aaa")))))
(custom-set-faces '(font-lock-comment-face
                    ((t (:slant italic ;;:weight light
                         :height 0.9 :foreground "#a2a2a2" :family "Source Code Pro")))))

;; otherwise it seems like it is getting overriden somehow
(add-hook 'after-init-hook
          #'(lambda()
              (custom-set-faces '(font-lock-variable-name-face
                                  ((t (:background "#daffef")))))
              ))

(custom-set-faces '(font-lock-function-name-face ((t (:foreground "#64f" :background "#faf7dc")))))
(custom-set-faces '(avy-lead-face ((t (:foreground "#fff" :background "#f5bbd0")))))
(custom-set-faces '(avy-lead-face-0 ((t (:foreground "#fff" :background "#afc7f9")))))
(custom-set-faces '(diredfl-dir-heading ((t (:foreground "#0a0b3a" :background "#ffd7e0")))))
(custom-set-faces '(magit-diff-base ((t (:foreground "#9a9a11" :background "#fefeeb")))))
(custom-set-faces '(magit-diff-base-highlight ((t (:foreground "#8a8a01" :background "#f5f5df")))))
(custom-set-faces '(magit-diff-added ((t (:foreground "#229922" :background "#ddffdd")))))
(custom-set-faces '(magit-diff-added-highlight ((t (:foreground "#1a8a1a" :background "#c3e3c3")))))
(custom-set-faces '(magit-diff-removed ((t (:foreground "#881111" :background "#feecec")))))
(custom-set-faces '(magit-diff-removed-highlight ((t (:foreground "#881111" :background "#f0cdcc")))))
(custom-set-faces '(magit-diff-hunk-heading-highlight ((t (:foreground "#555555" :background "#cecece"
                                                                       ;;:weight semi-bold
                                                                       )))))
(custom-set-faces '(org-done ((t (:box t)))))
;;(custom-set-faces '(org-headline-done ((t (:family "Source Code Pro")))))
#+end_src

** auto dim inactive buffer
#+begin_src emacs-lisp
(use-package auto-dim-other-buffers
  :ensure
  :defer 0.7
  :disabled ;; bug
  :config
  (auto-dim-other-buffers-mode t))

(use-package dimmer
  :ensure
  :defer 1
  :custom
  (dimmer-adjustment-mode :both)
  (dimmer-use-colorspace :cielab)
  (dimmer-fraction 0.25)
  (dimmer-debug-messages 2)
  ;;(dimmer-watch-frame-focus-events nil)
  :pretty-hydra (toggle-hydra ("UI" (("D" dimmer-mode "dimmer(g)" :toggle))))
  :config
  (with-eval-after-load 'forge-topic
    (set-face-attribute 'forge-topic-header-line nil :foreground 'unspecified)) ;; dimmer fails for ':foreground reset'
  (dimmer-configure-which-key)
  (with-eval-after-load 'company-box
    (dimmer-configure-company-box))
  (dimmer-configure-hydra)
  (dimmer-configure-magit)
  (dimmer-configure-org)
  (dimmer-configure-posframe)
  ;; WIP
  ;; (add-to-list 'dimmer-buffer-exclusion-regexps ".*tooltip.*")
  ;; (defun dimmer-lsp-ui-p ()
  ;;   "Return non-nil if current buffer is a lsp-ui buffer."
  ;;   (message "---")
  ;;   (message (buffer-name))
  ;;   (message (format "%s" (or (string-prefix-p " *lsp-ui-" (buffer-name)) (lsp-ui-doc--visible-p))))
  ;;   (or (string-prefix-p " *lsp-ui-" (buffer-name)) (lsp-ui-doc--visible-p))
  ;;   (lsp-ui-doc--visible-p)
  ;;   )
  ;; ;; workaround, dimmer-prevent-dimming-predicates doesn't work because of 'force' parameter inside 'dimmer-process-all'
  ;; (add-to-list 'dimmer-buffer-exclusion-predicates
  ;;              #'(lambda (buf)
  ;;                  (message (format "=%s" (lsp-ui-doc--visible-p)))
  ;;                  (lsp-ui-doc--visible-p)))
  ;; (add-to-list 'dimmer-prevent-dimming-predicates #'dimmer-lsp-ui-p)
  ;; (add-to-list 'dimmer-buffer-exclusion-regexps "^ \\*lsp-ui-doc.*\\*$")

  ;; having problems with lsp and others which I'm unable to solve
  ;; anyway, while using golden-ratio dimmer has little value
  ;; (dimmer-mode t)
  )
#+end_src

** minimap
#+begin_src emacs-lisp
(use-package minimap
  :ensure
  :diminish
  :custom
  (minimap-window-location 'right)
  (minimap-minimum-width 20)
  (minimap-major-modes '(prog-mode))
  (minimap-update-delay 0.5)
  :custom-face
  (minimap-font-face ((t (:family "Input Mono" :height 20))))
  (minimap-active-region-background ((t (:background "dark slate blue" :extend t))))
  :pretty-hydra (toggle-hydra ("Text" (("M" minimap-mode "minimap(g)" :toggle t))))
  :config
  (with-eval-after-load 'golden-ratio
    (add-to-list 'golden-ratio-inhibit-functions
                 #'(lambda () (and (fboundp 'minimap-get-window) (minimap-get-window)))))
  )
#+end_src

* * *bindings & interaction
** general.el
#+name: general
#+begin_src emacs-lisp
;; some problem with use-package and \" probably
(with-eval-after-load 'general
  (general-define-key :states '(normal visual motion) :keymaps 'override "C-\"" (general-simulate-key "<leader>")))
(use-package general
  :ensure :demand :after evil
  :config
  (general-evil-setup)
  (general-imap "k"
    (general-key-dispatch 'self-insert-command
      :timeout 0.1
      "j" 'evil-escape
      "m" (general-simulate-key "RET")))
  ;; (general-imap "SPC"
  ;;   (general-key-dispatch 'self-insert-command
  ;;     :timeout 0.1
  ;;     "SPC" 'evil-escape))
  
  (general-imap "л"
    (general-key-dispatch 'self-insert-command
      :timeout 0.05
      ;; "о" 'evil-escape ;; cyrillic
      "j" 'evil-escape ;; when it dispatches it actually handles 'j' (as "о" translates into it)
      ;; "ь" (general-simulate-key "RET")
      "m" (general-simulate-key "RET")
      ))
  
  ;; ;; todo - try for 'override keymap to make it generic?
  (advice-add 'evil-collection-ivy-setup
              :after #'(lambda (&rest r)
                         (general-nmap :keymaps 'ivy-minibuffer-map
                           "k"
                           (general-key-dispatch 'ivy-previous-line      
                             :timeout 0.1
                             "j" 'evil-escape
                             "m" 'ivy-done))
                         ))

  ;; trick to exit from god-mode using kj same way
  (general-def god-local-mode-map "k" 
    (general-key-dispatch (general-simulate-key "C-k")
      :timeout 0.1
      "j" 'keyboard-quit)) ;;evil-normal-state

  (general-imap "M-," 'god-execute-with-current-bindings)
  ;; todo - cannot make this work (dispatches ',m' as two keys so god exits on ','?)
  ;; (general-imap ","
  ;;               (general-key-dispatch 'self-insert-command
  ;;                 :timeout 0.1
  ;;                 "m" 'god-execute-with-current-bindings))
  )
#+end_src
** mouse&scroll
#+begin_src emacs-lisp
(use-package pixel-scroll
  :demand
  :custom
  (pixel-scroll-precision-use-momentum t)
  (pixel-scroll-precision-interpolate-page t)
  (scroll-margin 0)
  (scroll-preserve-screen-position t)
  (next-screen-context-lines 10)
  (mouse-wheel-tilt-scroll         t)
  (mouse-wheel-flip-direction      t)
  (redisplay-dont-pause            t) ;; Fully redraw the display before it processes queued input events.
  (next-screen-context-lines       2) ;; Number of lines of continuity to retain when scrolling by full screens
  (scroll-conservatively       10000) ;; only 'jump' when moving this far off the screen
  (scroll-step                     1) ;; Keyboard scroll one line at a time
  (scroll-error-top-bottom t)
  (mouse-wheel-progressive-speed nil) ;; Don't accelerate scrolling
  (mouse-wheel-follow-mouse        t) ;; Scroll window under mouse
  (fast-but-imprecise-scrolling    t) ;; No (less) lag while scrolling lots.
  (auto-window-vscroll           nil) ;; Cursor move faster
  (mouse-drag-and-drop-region t)
  ;; (mouse-yank-at-point t)
  (mouse-drag-copy-region t)
  :config
  ;; I'm actually not happy with it
  ;; (pixel-scroll-mode)
  ;; (pixel-scroll-precision-mode)
  ;; todo - bindings for smooth keyboard scroll
  ;; (global-set-key [next] #'good-scroll-up-full-screen)
  ;; (global-set-key [prior] #'good-scroll-down-full-screen)
  ;; (define-key evil-motion-state-map (kbd "s-j") 'my/good-scroll-up-30%-screen)
  ;; (define-key evil-motion-state-map (kbd "s-k") 'my/good-scroll-down-30%-screen)
  ;; (evil-define-key 'emacs global-map (kbd "C-v") 'good-scroll-up-full-screen)
  ;; (evil-define-key 'emacs global-map (kbd "M-v") 'good-scroll-down-full-screen)
  ;; fix horizontal scroll
  (setq mwheel-scroll-left-function 'scroll-right)
  (setq mwheel-scroll-right-function 'scroll-left)
  ;; I'm using pinch with libinput-gestures
  (global-set-key [pinch] 'ignore)
  :general ('override
            "s-j" 'pixel-scroll-interpolate-down
            "s-k" 'pixel-scroll-interpolate-up) ;; 'evil-scroll-down 'evil-scroll-up
  )

(defun enable-term-mouse ()
  (interactive)
  (unless window-system
    (xterm-mouse-mode 1)
    (global-set-key (kbd "<mouse-4>") 'scroll-down-line)
    (global-set-key (kbd "<mouse-5>") 'scroll-up-line)))

(use-package good-scroll
  :ensure
  :disabled ;; TODO-fix: it actually adds up ~2% of extra cpu all-time - becuase of constant re-rendering
  :defer 0.8
  :config
  ;; this doesn't  move to the very top of the window
  ;;(evil-define-key 'motion global-map (kbd "C-f") 'good-scroll-up-full-screen)
  ;;(evil-define-key 'motion global-map (kbd "C-b") 'good-scroll-down-full-screen)
  ;; (define-key evil-motion-state-map (kbd "s-j") 'evil-scroll-down)
  ;; (define-key evil-motion-state-map (kbd "s-k") 'evil-scroll-up)

  (defun my/good-scroll-up-30%-screen ()
    "Scroll up."
    (interactive)
    (good-scroll-move (ffloor (* 0.3 (good-scroll--window-usable-height)))))

  (defun my/good-scroll-down-30%-screen ()
    "Scroll down."
    (interactive)
    (good-scroll-move (ffloor (* -0.3 (good-scroll--window-usable-height)))))
  (when (display-graphic-p)
    (good-scroll-mode 1)
    (global-set-key [next] #'good-scroll-up-full-screen)
    (global-set-key [prior] #'good-scroll-down-full-screen)
    (define-key evil-motion-state-map (kbd "s-j") 'my/good-scroll-up-30%-screen)
    (define-key evil-motion-state-map (kbd "s-k") 'my/good-scroll-down-30%-screen)
    (define-key evil-motion-state-map (kbd "C-e") 'good-scroll-up)
    (define-key evil-motion-state-map (kbd "C-y") 'good-scroll-down)
    (evil-define-key 'emacs global-map (kbd "C-v") 'good-scroll-up-full-screen)
    (evil-define-key 'emacs global-map (kbd "M-v") 'good-scroll-down-full-screen)
    )
  :custom
  (good-scroll-duration 0.15)
  ;; below snippet came from somewhere, i keep it under good-scroll as a related
  ;; https://www.masteringemacs.org/article/improving-performance-emacs-display-engine
  ;; https://www.reddit.com/r/emacs/comments/8sw3r0/finally_scrolling_over_large_images_with_pixel/
  ;; https://www.reddit.com/r/emacs/comments/9rwb4h/why_does_fast_scrolling_freeze_the_screen/
  ;; https://emacs.stackexchange.com/questions/10354/smooth-mouse-scroll-for-inline-images
  ;; https://emacs.stackexchange.com/questions/28736/emacs-pointcursor-movement-lag
  (redisplay-dont-pause            t) ;; Fully redraw the display before it processes queued input events.
  (next-screen-context-lines       2) ;; Number of lines of continuity to retain when scrolling by full screens
  (scroll-conservatively       10000) ;; only 'jump' when moving this far off the screen
  (scroll-step                     1) ;; Keyboard scroll one line at a time
  (mouse-wheel-progressive-speed nil) ;; Don't accelerate scrolling
  (mouse-wheel-follow-mouse        t) ;; Scroll window under mouse
  (fast-but-imprecise-scrolling    t) ;; No (less) lag while scrolling lots.
  (auto-window-vscroll           nil) ;; Cursor move faster
  )

;; experimenting
(use-package inertial-scroll
  :disabled
  :quelpa (inertial-scroll :fetcher "github" :repo "kiwanami/emacs-inertial-scroll")
  :custom
  (inertias-friction 110)
  :bind
  (("<mouse-4>"     . inertias-down-wheel) ;; Replace mwheel-scroll
   ("<mouse-5>"     . inertias-up-wheel  ) ;; Replace mwheel-scroll
   ("<wheel-up>"    . inertias-down-wheel)
   ("<wheel-down>"  . inertias-up-wheel  ))) 

;; scroll one line at a time (less "jumpy" than defaults)
;;(setq mouse-wheel-scroll-amount '(1 ((shift) . 1)((meta)) ((control) . text-scale))) ;; one line at a time
;;(setq mouse-wheel-progressive-speed t);;nil ;; (not) accelerate scrolling
;;(setq mouse-wheel-follow-mouse 't) ;; scroll window under mouse
;;(setq scroll-step 1) ;; keyboard scroll one line at a time

;; multiple problems with this package: 1. no font size change. 2. line separator ^L problem (page-break-lines)
(use-package display-line-numbers
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook
            #'(lambda ()
                (add-hook 'prog-mode-hook #'display-line-numbers-mode))))

;; experimental
(use-package scrollkeeper
  :disabled
  :quelpa (scrollkeeper :fetcher github :repo "alphapapa/scrollkeeper.el")
  :general
  ;; ([remap scroll-up-command] #'scrollkeeper-contents-up
  ;;  [remap scroll-down-command] #'scrollkeeper-contents-down)
  ([remap evil-scroll-page-down] #'scrollkeeper-contents-up
   [remap evil-scroll-page-up] #'scrollkeeper-contents-down)
  )
#+end_src
** context-menu
#+begin_src emacs-lisp
;; (global-set-key [(down-mouse-2)] 'menu-bar-open)
;; (global-set-key [double-down-mouse-3] 'mouse-yank-at-click)
;; (global-set-key [double-mouse-3] 'mouse-yank-at-click)
;; (global-set-key [down-mouse-3] 'context-menu-open)
;; (global-set-key [down-mouse-3] nil)
;; (define-key context-menu-mode-map [double-down-mouse-3] 'mouse-yank-at-click)
;; (define-key context-menu-mode-map [down-mouse-3] nil)

(use-package mouse
  :demand
  :custom
  (context-menu-functions
   '(context-menu-undo
     context-menu-region
     context-menu-middle-separator
     context-menu-toolbar
     context-menu-global
     context-menu-local
     context-menu-minor
     context-menu-buffers
     context-menu-vc
     context-menu-ffap
     hi-lock-context-menu
     occur-context-menu
     Man-context-menu
     dictionary-context-menu))
  (touch-screen-display-keyboard t)
  (touch-screen-precision-scroll t)
  :config
  (context-menu-mode 1)

  ;; https://ruzkuku.com/texts/emacs-mouse.html
  (require 'eww)
  (defun mouse-online-search-at-point (e)
    "Search for word at point or selection."
    (interactive "e")
    (let ((query (if (use-region-p) (buffer-substring (region-beginning) (region-end))
                   (save-excursion (mouse-set-point e) (thing-at-point 'symbol)))))
      (unless query (user-error "Nothing to search for"))
      (browse-url (concat
                   eww-search-prefix
                   (mapconcat #'url-hexify-string (split-string query) "+")))))

  (defun context-menu-online-search (menu click)
    "Populate MENU with command to search online."
    (save-excursion
      (mouse-set-point click)
      (define-key-after menu [online-search-separator] menu-bar-separator)
      (define-key-after menu [online-search-at-mouse]
        '(menu-item "Online search" mouse-online-search-at-point
                    :help "Search for region or word online")))
    menu)

  (add-hook 'context-menu-functions #'context-menu-online-search)
  )
#+end_src

** chords
#+begin_src emacs-lisp
;; testing
(use-package key-chord
  :ensure
  :disabled
  :config
  (key-chord-mode 1)
  (key-chord-define-global "hj"     'undo)
  (key-chord-define-global ",."     "<>\C-b"))
#+end_src

** god
#+name: god
#+begin_src emacs-lisp
(use-package god-mode
  :after general evil
  :ensure :demand :diminish god-local-mode
  :config
  (with-eval-after-load 'which-key
    (which-key-enable-god-mode-support))
  ;; not the best implementation
  ;; (defun my-god-mode-update-cursor-type ()
  ;;   (setq cursor-type (if (or god-local-mode buffer-read-only) 'hollow 'box)))
  ;; (add-hook 'post-command-hook #'my-god-mode-update-cursor-type)
  :general
  (:states '(visual normal motion) "," 'god-execute-with-current-bindings)
  (:keymaps 'god-local-mode-map "i" #'god-local-mode)
  (:keymaps 'god-local-mode-map "," #'keyboard-quit)
  )
#+end_src

** ivy

#+begin_src emacs-lisp
(use-package prescient
  :ensure
  :disabled
  :preface (declare-function prescient-persist-mode "prescient")
                                        ;:functions (prescient-persist-mode)
  :config (prescient-persist-mode t)
  :custom
  (prescient-filter-method '(prefix literal regexp fuzzy initialism))
  (prescient-sort-full-matches-first t))

(use-package amx :ensure :disabled) ;; I notice some performance issues - amx runs in the background
#+end_src

#+name: counsel
#+begin_src emacs-lisp
(use-package counsel
  :pin melpa
  :ensure
  :demand
  :after ivy
  :functions counsel-mode
  :diminish
  :config
  (counsel-mode)
  (with-eval-after-load 'ivy
    ;; some stupid order of init?
    (run-with-idle-timer 1 nil #'(lambda () (diminish 'counsel-mode nil))))
  :custom (counsel-mode-override-describe-bindings nil)
  :bind (("M-y" . counsel-yank-pop)
         ("M-Y" . counsel-evil-registers)))

(global-set-key (kbd "M-x") 'counsel-M-x)
(global-set-key (kbd "C-x C-f") 'counsel-find-file)
#+end_src

#+begin_src emacs-lisp
(use-package ivy-prescient
  :ensure
  :disabled
  :demand :after ivy
  :config (ivy-prescient-mode)
  :custom (ivy-prescient-sort-commands '(:not swiper swiper-isearch ivy-switch-buffer)))

#+end_src

#+name: ivy
#+begin_src emacs-lisp
(use-package ivy
  :ensure
  :demand
  :after evil-collection
  :diminish
  :bind (("C-c C-r" . ivy-resume)
         ("C-x b" . ivy-switch-buffer)
         ("C-x B" . ivy-switch-buffer-other-window)
         ("C-c v" . ivy-push-view)
         ("C-c V" . ivy-pop-view)
         ("<s-up>" . ivy-push-view)
         ("<s-S-up>" . ivy-pop-view)
         ("<s-down>" . ivy-switch-view)
         (:map ivy-minibuffer-map ("C-c C-c" . hydra-ivy/body)))
  :custom
  (ivy-extra-directories '("../" "./"))
  (ivy-count-format "(%d/%d) ")
  (ivy-use-virtual-buffers t)
  (ivy-height 20)
  :config
  (ivy-mode)
  (setq ivy-re-builders-alist
        '(
          (ivy-switch-buffer . ivy--regex-fuzzy)
          ;; be careful with fuzzy - grep command doesn't like the transformed query
          (counsel-projectile-grep . ivy--regex-plus)
          (counsel-projectile-ag . ivy--regex-plus)
          (counsel-projectile-rg . ivy--regex-plus)
          (counsel-rg . ivy--regex-plus)
          (counsel-ag . ivy--regex-plus)
          (counsel-git-grep . ivy--regex-plus)
          (swiper . ivy--regex-plus)
          (swiper-isearch . ivy--regex-plus)
          (t . ivy--regex-fuzzy)))
  (with-eval-after-load 'evil-collection
    ;; all fuzzy init
    ;;(setq ivy-initial-inputs-alist nil)
    (evil-collection-ivy-setup)
    ;; todo - <spc> is not a prefix key
    ;;(evil-collection-define-key 'normal 'ivy-minibuffer-map (kbd "<SPC> <SPC>") 'ivy-done)
    ;; this is very missing in evil-collection
    (evil-collection-define-key '(insert normal) 'ivy-minibuffer-map
      (kbd "C-f") 'ivy-scroll-up-command
      (kbd "C-b") 'ivy-scroll-down-command
      (kbd "s-j") 'ivy-scroll-up-command
      (kbd "s-k") 'ivy-scroll-down-command)
    )
  )

(use-package find-file-in-project :ensure) ;;required by ivy?
#+end_src

#+begin_src emacs-lisp
(use-package ivy-hydra
  :ensure
  :after ivy)

(defun ivy-rich-switch-buffer-icon (candidate)
  (with-current-buffer
      (get-buffer candidate)
    (let ((icon (all-the-icons-icon-for-mode major-mode)))
      (if (symbolp icon)
          (all-the-icons-icon-for-mode 'fundamental-mode)
        icon))))

(use-package ivy-rich
  :ensure :pin melpa
  :demand :after counsel ivy
  :custom
  (ivy-virtual-abbreviate 'full
                          ivy-rich-switch-buffer-align-virtual-buffer t
                          ivy-rich-path-style 'abbrev)
  (ivy-rich-display-transformers-list
   '(ivy-switch-buffer
     (:columns
      (
       (ivy-rich-switch-buffer-icon (:width 2))
       (ivy-rich-candidate (:width 30))
       (ivy-rich-switch-buffer-size (:width 7))
       (ivy-rich-switch-buffer-indicators (:width 4 :face error :align right))
       (ivy-rich-switch-buffer-major-mode (:width 12 :face warning))
       (ivy-rich-switch-buffer-project (:width 15 :face success))
       (ivy-rich-switch-buffer-path (:width (lambda (x) (ivy-rich-switch-buffer-shorten-path x (ivy-rich-minibuffer-width 0.3)))))
       )
      :predicate
      (lambda (cand) (get-buffer cand)))))
  :config
  (ivy-rich-mode 1)
  (ivy-rich-project-root-cache-mode 1) ;; speed-up
  )

(use-package nerd-icons-ivy-rich :ensure
  :demand :after ivy-rich nerd-icons
  :init
  (nerd-icons-ivy-rich-mode 1)
  (run-with-idle-timer 1 nil #'nerd-icons-ivy-rich-reload) ;; omg why do I need this
  )

(use-package all-the-icons-ivy-rich :ensure
  :demand :after ivy-rich all-the-icons
  :disabled ;;nerds
  :config (all-the-icons-ivy-rich-mode 1))

(use-package all-the-icons-ivy
  :ensure
  :disabled ;; nerds
  :demand :after all-the-icons ivy-rich
  :config
  ;; (require 'all-the-icons)
  (setq all-the-icons-ivy-file-commands
        '(counsel-find-file counsel-file-jump counsel-recentf counsel-projectile-find-file counsel-projectile-find-dir))
  (all-the-icons-ivy-setup)
  )

; why :bind doesn't work?
(global-set-key (kbd "C-s") 'swiper-isearch)
(use-package swiper
  :ensure
  :after ivy
  :bind* ("C-s" . swiper-isearch)
  :config
  (custom-set-faces '(swiper-line-face ((t (:background "#c0c1c0")))))
  )

(use-package ivy-posframe
  :ensure
  :demand :after ivy
  :diminish
  :custom
  (ivy-posframe-width 120)
  (ivy-posframe-height 20)
  (ivy-posframe-parameters
   '((left-fringe . 8)
     (right-fringe . 8)))
  (ivy-posframe-display-functions-alist
   '(
     (swiper-isearch  . ivy-display-function-fallback)
     (swiper          . ivy-display-function-fallback)
     (complete-symbol . ivy-posframe-display-at-point)
     (counsel-M-x     . ivy-posframe-display-at-frame-bottom-left)
     (t               . ivy-posframe-display-at-frame-center)))
  :config
  (unless is-android
    (add-hook 'ivy-mode-hook #'ivy-posframe-mode))
  ;;:hook (ivy-mode . ivy-posframe-mode)
  )
#+end_src

** helpers & info

#+begin_src emacs-lisp
(use-package which-key
  :ensure
  :after evil
  :defer 0.6
  :diminish
  :custom
  (which-key-add-column-padding 0)
  (which-key-allow-evil-operators t)
  (which-key-max-description-length 50)
  (which-key-idle-delay 0.7)
  (which-key-show-operator-state-maps t)
  (which-key-side-window-max-height 0.4)
  :config
  (which-key-mode)
  (evil-define-key '(normal motion visual) global-map "?" 'which-key-show-full-major-mode))

(use-package which-key-posframe
  ;; :when (display-graphic-p)
  :ensure
  :demand :after which-key evil
  :config
  (unless is-android
    (which-key-posframe-mode)))

(use-package elisp-refs :ensure :demand)

(use-package helpful
  :ensure
  :after evil general
  :general
  (:states 'motion "<leader>h" 'hydra-help/body)
  (:states '(normal motion visual) :keymaps '(help-mode-map helpful-mode-map) "q" 'quit-window-kill-buffer) ;; I don't want dangling helpful buffers 
  :commands (hydra-help/body)
  :custom
  (help-window-select t) ;; these are not from helpful but here is the place
  (describe-bindings-outline t)
  (apropos-do-all t)
  :config
  ;; fix this annoying popping help buffers
  ;; possible, but doesn't work if I navigate elisp after help in that window
  ;; (add-to-list 'display-buffer-alist
  ;;              '("\\*helpful" . (display-buffer-reuse-mode-window . ((mode . (helpful-mode))))))
  ;; this one is fine but doesn't quite work when from treemacs buffer in multiple tabs
  ;; from https://emacs.stackexchange.com/questions/50650/how-to-display-help-buffers-below-one-specific-window
  (add-to-list 'display-buffer-alist
               '("\\*help"
                 ;; see https://www.gnu.org/software/emacs/manual/html_node/elisp/Displaying-Buffers-in-Side-Windows.html
                 (display-buffer-reuse-window display-buffer-in-side-window)
                 ;; see https://www.gnu.org/software/emacs/manual/html_node/elisp/Buffer-Display-Action-Alists.html
                 (side . right)
                 (slot . -1)             ; in the middle bottom
                 (window-width . 0.5)
                 (reusable-frames . nil)))
  :bind
  ;; in terminal C-h is basically a backspace
  (("C-c C-h" . help-command)
   ("C-h f" . helpful-callable)
   ("C-h v" . helpful-variable)
   ("C-h k" . helpful-key)
   ;; ("C-h C-b" . describe-prefix-bindings) ; it is actuall works like that: press C-h after prefix key
   ("C-h j" . helpful-at-point)
   ("C-h F" . helpful-function)
   ("C-h C" . helpful-command)
   ("C-h M-m" . helpful-macro))
  ;;todo - use general?
  ;;("C-h" . help-hydra/body)
  :pretty-hydra
  (hydra-help
   (:color teal :quit-key "q" :title (with-faicon "stethoscope" "Help" 1 -0.05))
   ("Functions & Variables"
    (("F" helpful-callable "callable")
     ("v" helpful-variable "variable") ;; counsel-describe-variable
     ("j" helpful-symbol "symbol") ;; counsel-describe-symbol
     ("c" helpful-command "command")
     ("h" helpful-at-point "at-point")
     ("f" helpful-function "function") ;; counsel-describe-function
     ("M" helpful-macro "macro")
     ("l" apropos-local-value "local value")
     ("M-l" apropos-local-variable "local variable"))
    "Info, Pkgs, Other"
    (("I" counsel-info-lookup-symbol "counsel info symbol")
     ("i" info-lookup-symbol "info symbol")
     ("r" info-emacs-manual "emacs info")
     ("R" info-display-manual "pick info")
     ("a" counsel-apropos "apropos docs")
     ("A" apropos "apropos all info")
     ("p" describe-package "package")
     ("L" counsel-find-library "library")
     ("P" counsel-package "counsel pkg")
     ("uf" counsel-describe-face "describe face")
     ("uF" counsel-faces "faces")
     ("uc" describe-char))
    "Keys & Bindings"
    (("k" helpful-key "key")
     ("C-k" describe-key-briefly "key brief")
     ("m" describe-mode "mode")
     ("M-m" describe-minor-mode "minor mode")
     ("B" describe-bindings "bindings")
     ("b" counsel-descbinds "counsel binds")
     ("M-k" describe-keymap "keymap")
     ("E" evil-collection-describe-bindings "evil-collection")
     ("C-l" view-lossage)
     ("C-c" list-command-history "command history")
     ("M-K" describe-personal-keybindings "personal bind-keys")
     ("wk" which-key-show-full-keymap "full keymap")
     ("wM" which-key-show-full-major-mode "full major")
     ("wm" which-key-show-full-minor-mode-keymap "full minor")))))

;;(use-package discover-my-major) ;; not very helpful

(use-package info+
  :unless (eq system-type 'windows-nt)
  :requires bookmark+
  ;; :disabled ;; requires bmkp, which requires something else that doesn't work in 29.1
  :demand :after info evil-collection bookmark+
  :quelpa (info+ :fetcher wiki)
  :config
  (general-def :states '(motion normal visual insert) :keymaps 'Info-mode-map "M-h" 'tab-line-prev-tab-cycle))

(use-package info-colors
  :ensure
  :hook
  (Info-selection . info-colors-fontify-node))

(use-package keyfreq :ensure)

(use-package ace-link
  :ensure
  :general (:keymaps 'Info-mode-map :states 'normal "o" 'ace-link-info))
#+end_src

** evil

#+name: evil
#+begin_src emacs-lisp
(use-package evil
  :ensure
  :defer 0.2
  :init
  (setq evil-want-C-i-jump nil)
  ;; these 2 are for evil-collection
  (setq evil-want-integration t) ;; This is optional since it's already set to t by default.
  (setq evil-want-keybinding nil)
  (global-unset-key (kbd "C-z"))
  :config
  (evil-mode)
  (evil-set-leader 'motion (kbd "<SPC>"))
  (evil-set-leader 'insert (kbd "s-,"))
  (add-to-list 'evil-emacs-state-modes 'debugger-mode)
  ;; :experiment: in progress
  (define-key prog-mode-map [(double-mouse-1)] 'evil-goto-definition)
  (define-key prog-mode-map [(double-down-mouse-1)] 'evil-goto-definition)
  (add-hook 'server-after-make-frame-hook #'(lambda ()
                                              (when (display-graphic-p)
                                                (define-key input-decode-map [(control ?i)] [control-i])
                                                (define-key input-decode-map [(control ?I)] [(shift control-i)])
                                                (define-key evil-motion-state-map [tab] nil)
                                                (define-key evil-motion-state-map [control-i] 'evil-jump-forward))
                                              ))
  ;; ;; annoying - when I select and paste it puts selected into register
  ;; (defun evil-paste-after-from-0 ()
  ;;   (interactive)
  ;;   (let ((evil-this-register ?0))
  ;;     (call-interactively 'evil-paste-after)))
  ;; (define-key evil-visual-state-map "p" 'evil-paste-after-from-0)
  ;; (define-key evil-visual-state-map "p" 'evil-paste-after)
  ;; These are the keybindings evil makes in insert state by default:
  ;; +-----+----------------------------+----------------------+
  ;; |key  |command                     |emacs                 |
  ;; |     |                            |default               |
  ;; +-----+----------------------------+----------------------+
  ;; |C-v  |quoted-insert               |scroll-up-command     |
  ;; +-----+----------------------------+----------------------+
  ;; |C-k  |evil-insert-digraph         |kill-line             |
  ;; +-----+----------------------------+----------------------+
  ;; |C-o  |evil-execute-in-normal-state|open-line             |
  ;; +-----+----------------------------+----------------------+
  ;; |C-r  |evil-paste-from-register    |isearch-backward      |
  ;; +-----+----------------------------+----------------------+
  ;; |C-y  |evil-copy-from-above        |yank                  |
  ;; +-----+----------------------------+----------------------+
  ;; |C-e  |evil-copy-from-below        |move-end-of-line      |
  ;; +-----+----------------------------+----------------------+
  ;; |C-n  |evil-complete-next          |next-line             |
  ;; +-----+----------------------------+----------------------+
  ;; |C-p  |evil-complete-previous      |previous-line         |
  ;; +-----+----------------------------+----------------------+
  ;; |C-x  |evil-complete-next-line     |set-goal-column       |
  ;; |C-n  |                            |                      |
  ;; +-----+----------------------------+----------------------+
  ;; |C-x  |evil-complete-previous-line |mark-page             |
  ;; |C-p  |                            |                      |
  ;; +-----+----------------------------+----------------------+
  ;; |C-t  |evil-shift-right-line       |transpose-chars       |
  ;; +-----+----------------------------+----------------------+
  ;; |C-d  |evil-shift-left-line        |delete-char           |
  ;; +-----+----------------------------+----------------------+
  ;; |C-a  |evil-paste-last-insertion   |move-beginning-of-line|
  ;; +-----+----------------------------+----------------------+
  ;; |C-w  |evil-delete-backward-word or|kill-region           |
  ;; |     |evil-window-map             |                      |
  ;; +-----+----------------------------+----------------------+
  (with-eval-after-load "evil-maps"
    ;; these are absolutely useless for me
    (evil-global-set-key 'insert "\C-y" nil)
    (evil-global-set-key 'insert "\C-e" nil)
    (evil-global-set-key 'insert "\C-a" nil)
    ;; free up standard code nav binds
    ;; evil-repeat-pop-next
    ;;(evil-global-set-key 'normal "\M-." nil)
    (define-key evil-normal-state-map (kbd "M-.") nil)
    )
  :custom
  ;; this is required even by evil-collection-ivy
  (evil-want-minibuffer t)
  (evil-want-Y-yank-to-eol t) ;; experimenting
  (evil-cross-lines t) ;; experimenting
  (evil-want-fine-undo t) ;; experimenting
  (evil-want-visual-char-semi-exclusive t) ;; makes v$ not select newline (annoying)
  (evil-respect-visual-line-mode t)
  (evil-undo-system 'undo-redo))
#+end_src

#+name: evil-collection
#+begin_src emacs-lisp
(use-package evil-collection
  :ensure
  :demand :after evil 
  :init
  (setq evil-collection-setup-minibuffer t) ;; before 'require' otherwise it doesn't work
  (setq evil-collection-want-unimpaired-p nil) ;; conflicts [,] bindings in org-evil-agenda
  :config
  (setq evil-collection-mode-list (delete 'ediff evil-collection-mode-list)) ;; having trouble with this guy
  (evil-collection-init)
  ;;fix space for some modes, see evil-org-agenda as well
  (general-def '(motion normal) ;; dired-mode is overriden in dired-mode package config section
    (help-mode-map Info-mode-map custom-mode-map Custom-mode-map process-menu-mode-map)
    "SPC" (general-simulate-key "<leader>"))
  )
#+end_src

#+name: other-evil
#+begin_src emacs-lisp
;; surround using S<symbol> or yS<symb>
(use-package evil-surround
  :ensure
  :after evil
  :config
  ;;(global-evil-surround-mode 1) ; will toggle on-demand in hydra-toggle
  (add-to-list 'evil-surround-operator-alist '(evil-cp-change . change))
  (add-to-list 'evil-surround-operator-alist '(evil-cp-delete . delete)))

(use-package multiple-cursors
  :ensure
  :after evil
  :init
  (defvar my-mc-map (make-sparse-keymap) "Keymap for \"mutliple-cursors\" shortcuts.")
  (define-key evil-normal-state-map (kbd "g y") my-mc-map)
  :bind
  (:map
   my-mc-map
   ("s" . mc/edit-lines)
   ("n" . mc/mark-next-like-this)
   ("p" . mc/mark-previous-like-this)
   ("a" . mc/mark-all-like-this)))

(use-package evil-mc
  :ensure
  :after evil evil-collection
  :config
  (evil-collection-evil-mc-setup)
  ;; conflict with evil-collection
  (defvar my-evil-mc-map (make-sparse-keymap) "Keymap for \"evil-mc\" shortcuts.")
  (define-key evil-normal-state-map (kbd "g s") my-evil-mc-map)
  (define-key my-evil-mc-map "m" 'evil-mc-make-all-cursors)
  (define-key my-evil-mc-map "u" 'evil-mc-undo-all-cursors)
  (define-key my-evil-mc-map "s" 'evil-mc-pause-cursors)
  (define-key my-evil-mc-map "r" 'evil-mc-resume-cursors)
  (define-key my-evil-mc-map "f" 'evil-mc-make-and-goto-first-cursor)
  (define-key my-evil-mc-map "l" 'evil-mc-make-and-goto-last-cursor)
  (define-key my-evil-mc-map "h" 'evil-mc-make-cursor-here)
  (define-key my-evil-mc-map "j" 'evil-mc-make-cursor-move-next-line)
  (define-key my-evil-mc-map "k" 'evil-mc-make-cursor-move-prev-line)
  (define-key my-evil-mc-map "n" 'evil-mc-skip-and-goto-next-match)
  (define-key my-evil-mc-map "p" 'evil-mc-skip-and-goto-prev-match)
  (define-key my-evil-mc-map "N" 'evil-mc-skip-and-goto-next-cursor)
  (define-key my-evil-mc-map "P" 'evil-mc-skip-and-goto-prev-cursor)
  (define-key my-evil-mc-map (kbd "M-n") 'evil-mc-make-and-goto-next-cursor)
  (define-key my-evil-mc-map (kbd "M-p") 'evil-mc-make-and-goto-prev-cursor)
  (define-key my-evil-mc-map (kbd "C-n") 'evil-mc-make-and-goto-next-match)
  (define-key my-evil-mc-map (kbd "C-p") 'evil-mc-make-and-goto-prev-match)
  (define-key my-evil-mc-map (kbd "C-t") 'evil-mc-skip-and-goto-next-match))

;; 'localized' avy
(use-package evil-snipe
  :ensure :demand :after evil
  :diminish (evil-snipe-local-mode . "") ;; " +"
  :custom
  (evil-snipe-scope 'visible)
  (evil-snipe-smart-case t)
  :config
  (add-to-list 'evil-snipe-disabled-modes 'ibuffer-mode)
  (evil-snipe-mode 1)
  (evil-snipe-override-mode 1))

;; number of matches when searching
(use-package evil-anzu
  :disabled ;; I'm mostly using swiper
  :ensure :after evil anzu)

;; evil-anzu actually requires this
(use-package anzu
  :disabled ;; I'm mostly using swiper
  :ensure
  :init (global-anzu-mode +1))
#+end_src

#+name: evil-escape
#+begin_src emacs-lisp
(use-package evil-escape
  :ensure
  :demand
  :after evil
  ;; :config
  ;; I'm using general to handle actual keypress
  ;; (evil-escape-mode)
  ;; (setq-default evil-escape-key-sequence "kj")
  ;; (setq evil-escape-delay 0.1)
)
#+end_src

** avy

#+begin_src emacs-lisp
;; navigate text in the buffer
(use-package avy
  :ensure
  :after evil
  :commands (hydra-avy/body avy-goto-char-timer)
  ;;:general ('(normal motion insert) 'override "M-." 'avy-goto-char-2)
  :init (evil-define-key 'motion global-map
          (kbd "<leader>J") 'hydra-avy/body
          (kbd "<leader>j") 'avy-goto-char-timer)
  :custom (avy-timeout-seconds 0.3)
  :pretty-hydra
  (hydra-avy
   (:exit t :hint nil :title "Avy")
   ("Line"
    (("y" avy-copy-line)
     ("m" avy-move-line)
     ("k" avy-kill-whole-line))
    "Regionavy/body"
    (("Y" avy-copy-region)
     ("M" avy-move-region)
     ("K" avy-kill-region))
    "Goto"
    (("j" avy-goto-char-timer)
     ("w" avy-goto-word-1)
     ("l" avy-goto-line))
    ""
    (("c" avy-goto-char)
     ("W" avy-goto-word-0)
     ("L" avy-goto-end-of-line)
     ("C" avy-goto-char-2)))))
#+end_src

* * *text & editing
** text & editing tools
#+begin_src emacs-lisp
(use-package text-mode
  :demand
  :custom
  (adaptive-fill-mode t)
  (fill-column 100)
  ;;(show-paren-delay 0.5)
  (sentence-end-double-space nil)
  :diminish
  ((auto-fill-function . " fil")
   (visual-line-mode . " vis"))
  :config
  ;;(electric-indent-mode 0) ;; it makes indentations messy in org, I'm using org-indent-mode
  (delete-selection-mode 1) ;; omg how could I live without this - to remove selection (if active) when inserting text
  (global-hl-line-mode 1) ;; could disable in favor of pixel-scroll speed if used
  (setq-default indent-tabs-mode nil
                tab-width 4)
  (global-set-key (kbd "C-M-<backspace>") 'contextual-backspace)
  (global-set-key (kbd "C-c w") 'toggle-truncate-lines)
  :general (:states 'motion "<leader>," 'hydra-text/body)
  ;; :general (motion 'global "<leader>," 'powerthesaurus-hydra/body)
  :pretty-hydra
  (hydra-text
   (:color teal :quit-key "q" :title (with-faicon "pencil" "Text" 1 -0.05))
   ("Editing"
    (("i" iedit-mode "iedit")
     ("SPC" shrink-whitespace "shrink whitespace"))
    "Writing"
    (("w" my/enter-writing-mode "writing mode"))
    "Words"
    (("t" google-translate-query-translate "translate")
     ("," powerthesaurus-hydra/body "powerthesaurus")
     ("s" synosaurus-lookup "synosaurus"))
    ;; "TTS"
    ;; (("m" piper-read-region "piper read region"))
    ))
  :init
  (defun contextual-backspace ()
    "Hungry whitespace or delete word depending on context."
    (interactive)
    (if (looking-back "[[:space:]\n]\\{2,\\}" (- (point) 2))
        (while (looking-back "[[:space:]\n]" (- (point) 1))
          (delete-char -1))
      (cond
       ((and (boundp 'smartparens-strict-mode) smartparens-strict-mode)
        (sp-backward-kill-word 1))
       ((and (boundp 'subword-mode) subword-mode)
        (subword-backward-kill 1))
       (t (backward-kill-word 1)))))
  :hook
  (text-mode . (lambda ()
                 ;; (auto-fill-mode)
                 (paragraph-indent-minor-mode)
                 (visual-line-mode t)
                 (visual-fill-column-mode t)
                 (display-fill-column-indicator-mode)
                 )))

(use-package outline-mode
  :config
  (general-def 'normal 'outline-mode-map
    (kbd "M-h") nil
    (kbd "M-j") nil
    (kbd "M-k") nil
    (kbd "M-l") nil
    )
  )

;;(use-package beacon
;;  :custom
;;  (beacon-color "#f1fa8c")
;;  :hook (after-init . beacon-mode))

;; string manipulation (not really using directly right now)
;;(use-package s)

(use-package visual-regexp
  :ensure
  :bind
  (("M-%" . vr/replace)
   ("M-C-%" . vr/query-replace)
   ("C-c m" . vr/mc-mark))) ;; todo - into text hydra

(use-package expand-region
  :ensure
  :after evil
  :commands 'er/expand-region
  :init
  (evil-define-key 'motion global-map (kbd "<leader>v") 'er/expand-region))

(use-package mixed-pitch
  :ensure
  ;;:hook
  ;;(text-mode . mixed-pitch-mode)
  )

(use-package shrink-whitespace
  :ensure
  :bind ("M-\\" . shrink-whitespace))

(use-package mwim :ensure
  :general
  ("C-a" 'mwim-beginning
   "C-e" 'mwim-end))

(use-package view-mode
  :general (normal view-mode-map "SPC" nil))

(use-package iedit :ensure
  :bind ("C-;" . iedit-mode))

(use-package crux
  :ensure
  ;;:bind
  ;;("M-<backspace>" . crux-kill-line-backwards)
  )

;; testing
(use-package easy-kill
  :ensure
  :bind
  ([remap kill-ring-save] . easy-kill)
  ([remap mark-sexp] . easy-mark) ;; sort of evil-surround but different
  :custom
  (kill-ring-max 300))

#+end_src
** writing & grammar
#+begin_src emacs-lisp
(defun my/enter-writing-mode ()
  "Apply various modes and settings for writing"
  (interactive)
  (org-narrow-to-subtree)
  (olivetti-mode 1)
  (wc-mode)
  (writegood-mode)
  (mixed-pitch-mode 1)
  ;;(variable-pitch-mode 1)
  ;;(set-face-attribute 'variable-pitch nil :family "IBM Plex Serif" :height 110)
  ;;(set-face-attribute 'variable-pitch nil :family "DejaVu Serif" :height 110)
  ;;(set-face-attribute 'default nil :family "DejaVu Sans Mono" :height 130)
  ;;(set-face-attribute 'fixed-pitch nil :family "DejaVu Sans Mono")
  )

(use-package olivetti :ensure
  :custom (olivetti-body-width 140))

(use-package wc-mode :ensure)

(use-package writegood-mode :ensure)

(use-package writeroom-mode :ensure)

(use-package flycheck-grammarly :ensure)

(use-package focus :ensure :disabled) ;; meh

;; thesaurus
(use-package synosaurus :ensure
  :custom (synosaurus-choose-method 'default))

(use-package powerthesaurus :ensure)
#+end_src

** google-translate

#+begin_src emacs-lisp
; doesn't work
;(use-package go-translate
;  :config
;  (setq go-translate-local-language "en")
;  (setq go-translate-target-language "uk")
;  (setq go-translate-extra-directions '(("uk" . "ru") ("ru" . "en")))
;  (setq go-translate-buffer-follow-p t)       ; focus the result window
;  (setq go-translate-buffer-source-fold-p t)  ; fold the source text in the result window
;  (setq go-translate-buffer-window-config nil) ; config the result window as your wish
;  (setq go-translate-debug-p t)
;  (global-set-key "\C-ct" 'go-translate)
;  (global-set-key "\C-cT" 'go-translate-popup))

; crazy, finally it works
(use-package google-translate
  :disabled
  :ensure
  ;:init
  ;(require 'google-translate)
  ;(require 'google-translate-smooth-ui)
  ;(defun google-translate--search-tkk () "Search TKK." (list 430675 2721866130))
  :functions (google-translate--search-tkk)
  :config
  (require 'google-translate-smooth-ui)
  (defun google-translate--search-tkk () "Search TKK." (list 430675 2721866130))
  ;todo - fix minibuffer keymap with evil for directions
  ;(evil-define-key '(motion normal insert) minibuffer-local-map)
  :custom
  (google-translate-input-method-auto-toggling t)
  (google-translate-preferable-input-methods-alist '((nil . ("en")) (ukrainian-computer . ("ru" "uk"))))
  (google-translate-translation-directions-alist '(("uk" . "en") ("ru" . "en") ("en" . "uk")))
  ;(google-translate--tkk-url "http://translate.google.com/")
  ;(google-translate-base-url "http://translate.google.com/")
  ;(google-translate-backend-debug t)
  (google-translate-backend-method 'curl)
  (google-translate-show-phonetic t)
  :bind
  ("C-c C-t t" . google-translate-smooth-translate)
  ("C-c C-t p" . google-translate-at-point)
  ("C-c C-t q" . google-translate-query-translate)
  ("C-c C-t d" . google-translate-query-translate-using-directions)
  )
#+end_src

** epoch timestamps view
#+begin_src emacs-lisp :tangle no
;; testing
(use-package epoch-view :ensure)

;; Work in progress
(add-hook 'js-mode-hook
          (lambda ()
            (font-lock-add-keywords nil
                                    '(("^[0-9]+"
                                       (0 `(face nil display
                                                 ,(format-time-string "%F %T"
                                                                      (seconds-to-time
                                                                       (car (read-from-string
                                                                             (concat "1292527019" ".0"))))))))))))


(defvar unix-ts-font-lock-keywords
  '(("168[0-9]+" (0 `(face
                      nil display
                      ,(format-time-string
                        "%F %T"
                        (seconds-to-time
                         (car
                          (read-from-string
                           (concat "1292527019" ".0")))))))))
  "Timestamp font-lock")

(define-minor-mode ts-show-mode
  "Enable showing timestamps as dates in buffer."
  :lighter "TS"
  (if ts-show-mode (font-lock-add-keywords nil unix-ts-font-lock-keywords)
    (font-lock-remove-keywords nil `(,@unix-ts-font-lock-keywords))))

(with-eval-after-load 'pretty-hydra
  (pretty-hydra-define+ toggle-hydra nil ("Emacs" (("C-m" message-ts-mode "message-ts-mode" :toggle t)))))
#+end_src

** tex
#+begin_src emacs-lisp :tangle no
(use-package auctex
  :ensure
  :config
  (setq preview-auto-cache-preamble nil))

(use-package auto-complete-auctex
  :ensure
  :demand
  :after auctex)

;; it came from here https://github.com/karthink/.emacs.d/blob/f25889bb31e7b4f39243b5a80485a75a2ce65430/init.el#L1090
(use-package cdlatex
  :ensure
  :hook (LaTeX-mode . turn-on-cdlatex)
  :config
  (progn
    (setq cdlatex-command-alist
          '(("vc" "Insert \\vect{}" "\\vect{?}"
             cdlatex-position-cursor nil nil t)
            ("smat" "Insert smallmatrix env"
             "\\left( \\begin{smallmatrix} ? \\end{smallmatrix} \\right)"
             cdlatex-position-cursor nil nil t)
            ("bmat" "Insert bmatrix env"
             "\\begin{bmatrix} ? \\end{bmatrix}"
             cdlatex-position-cursor nil nil t)
            ("pmat" "Insert pmatrix env"
             "\\begin{pmatrix} ? \\end{pmatrix}"
             cdlatex-position-cursor nil nil t)
            ("equ*" "Insert equation* env"
             "\\begin{equation*}\n?\n\\end{equation*}"
             cdlatex-position-cursor nil t nil)
            ("sn*" "Insert section* env"
             "\\section*{?}"
             cdlatex-position-cursor nil t nil)
            ("ss*" "Insert subsection* env"
             "\\subsection*{?}"
             cdlatex-position-cursor nil t nil)
            ("sss*" "Insert subsubsection* env"
             "\\subsubsection*{?}"
             cdlatex-position-cursor nil t nil)))

    (setq cdlatex-math-symbol-alist '((?F ("\\Phi"))
                                      (?o ("\\omega" "\\mho" "\\mathcal{O}"))
                                      (?6 ("\\partial"))
                                      (?v ("\\vee" "\\forall"))))
    (setq cdlatex-math-modify-alist '((?b "\\mathbb" "\\textbf" t nil nil)
                                      (?B "\\mathbf" "\\textbf" t nil nil)))
    (setq cdlatex-paired-parens "$[{("))
  )
#+end_src

** layout
#+begin_src emacs-lisp
(defun insert-canary-helper ()
  "simple cheat sheet to learn my custom canary layout"
  (interactive)
  (insert "
`lypk zfou\\
crstg x eai
jvmdb qw,./
  h:- ='n"))
#+end_src
* * *files & projects
** common
#+begin_src emacs-lisp
(use-package files
  :demand
  :general (:states 'motion "<leader>f" 'counsel-find-file)
  :custom
  (save-interprogram-paste-before-kill t)
  (global-auto-revert-mode t)
  ;; todo - filter out archive files from org
  (recentf-max-saved-items 100)
  (create-lockfiles nil)
  (make-backup-files nil)
  :config
  ;; (global-hl-line-mode 1) ;; disabled in favor of pixel-scroll speed
  (auto-insert-mode t)
  (save-place-mode 1) ; remember file position in the visited previously file
  ;; lets keep it light and enable explicitly on demand
  ;; (global-so-long-mode 1)

  )

;; large files
(use-package vlf
  :functions ivy-add-actions
  :ensure
  :after (ivy counsel)
  :init (ivy-add-actions 'counsel-find-file '(("l" vlf "view large file"))))
#+end_src

** dired

#+begin_src emacs-lisp
(use-package async :ensure)
(use-package dired-avfs ;; archives
  :ensure :demand :after dired
  ;; :ensure-system-package avfs
  )
(use-package dired-hide-dotfiles :ensure :demand :after dired)
(use-package dired-filter :ensure);; :demand :after dired) ;; additional filter keymap
(use-package dired-open :ensure :demand :after dired) ;; xdg-open
(use-package dired-subtree :ensure :demand :after dired
  :config
  (general-def normal dired-mode-map "C-M-p" 'dired-subtree-previous-sibling "C-M-n" 'dired-subtree-next-sibling)
  ;; these are set in the 'other faces' section
  ;; (custom-set-faces
  ;;  '(dired-subtree-depth-1-face ((t (:background "#e8e8d7"))))
  ;;  '(dired-subtree-depth-2-face ((t (:background "#c8c8c7"))))
  ;;  '(dired-subtree-depth-3-face ((t (:background "#b8b8b7"))))
  ;;  )
  :custom (dired-subtree-line-prefix "   ")) ;;"  └───"
(use-package dired-narrow :ensure :after dired) ;; narrow-fuzzy
(use-package dired-hacks-utils :ensure :demand :after dired)
(use-package dired-du :ensure :after dired)
(use-package dired-git-info :ensure :after dired
  ;; doesn't play well with dired-subtree
  ;; :hook (dired-after-readin . dired-git-info-auto-enable)
  :custom (dgi-commit-message-format "%C(cyan)%an %C(auto)%<(50,trunc)%s")
  :general (:states 'normal :keymaps 'dired-mode-map "}" 'dired-git-info-mode)
  )
(use-package dired-collapse :ensure :after dired;; displays dir1/dir2/.., bad when trying to copy/move those files
  ;; :hook (dired-mode . dired-collapse-mode)
  )
;; not sure if it's really being used - more colorful faces
;; it seems like it doesn't work with dired-fl
(use-package dired-rainbow :ensure :after dired
  :config
  (dired-rainbow-define html "#4e9a06" ("htm" "html" "xhtml"))
  (dired-rainbow-define log (:inherit default :italic t) ".*\\.log") ; highlight executable files, but not directories
  (dired-rainbow-define-chmod executable-unix "Green" "-[rw-]+x.*")
  ;; see github documentation of dired-hack-utils for more
  )
;;(use-package ranger) ;; don't like it
;;(use-package treemacs-icons-dired :ensure :after treemacs dired)
(use-package all-the-icons-dired :ensure :after dired all-the-icons
  :diminish " Icons"
  :disabled ;; nerds are better
  :hook (dired-mode . all-the-icons-dired-mode)
  )
(use-package nerd-icons-dired :ensure :after dired nerd-icons
  :diminish
  :hook (dired-mode . nerd-icons-dired-mode))

;;preview like in ranger (or dirvish, but dirvish is better)
(use-package peep-dired
  :ensure :after evil general dired
  :init
  ;; kind of ranger preview
  (defvar my/display-buffer-alist-on-right
    '((".*"
       (display-buffer-reuse-window
        display-buffer-in-side-window)
       (side . right)
       (slot . 0)
       (window-width . 0.7)
       (reusable-frames . nil)))
    "Display buffers on right side.")
  (defun my/peep-dired-next-file ()
    (interactive)
    (let ((display-buffer-alist my/display-buffer-alist-on-right))
      (peep-dired-next-file)))
  (defun my/peep-dired-prev-file ()
    (interactive)
    (let ((display-buffer-alist my/display-buffer-alist-on-right))
      (peep-dired-prev-file)))
  (defun my/peep-dired ()
    (interactive)
    (let ((display-buffer-alist my/display-buffer-alist-on-right))
      (peep-dired)))
  :config
  (with-eval-after-load 'golden-ratio
    (add-to-list 'golden-ratio-inhibit-functions #'(lambda () peep-dired)))

  :general
  (:states 'normal :keymaps 'peep-dired-mode-map
           "M-<SPC>" 'peep-dired-scroll-page-down
           "M-S-<SPC>" 'peep-dired-scroll-page-up
           "<backspace>" 'peep-dired-scroll-page-up
           "q" 'peep-dired
           ")" 'peep-dired
           "j" 'my/peep-dired-next-file
           "k" 'my/peep-dired-prev-file)
  (:states 'normal :keymaps 'dired-mode-map
           ")" 'my/peep-dired
           "M-k" #'(lambda ()
                     (interactive)
                     (peep-dired-cleanup)
                     (quit-window-kill-buffer)))
  ;; :custom (peep-dired-cleanup-eagerly t)
  :hook (peep-dired . evil-normalize-keymaps))

(use-package image-dired
  :hook (image-dired-thumbnail-mode
         . (lambda ()
             (setq-local global-hl-line-mode nil) ;; disable global mode
             ))
  :config
  (when (eq system-type 'windows-nt)
    (setq
     image-dired-cmd-create-thumbnail-program "magick.exe"
     image-dired-cmd-create-temp-image-program "magick.exe"
     image-dired-cmd-rotate-original-program "jpegtran.exe"
     image-dired-cmd-rotate-thumbnail-program "magick.exe")
    (add-to-list 'image-dired-cmd-create-thumbnail-options "convert")
    (add-to-list 'image-dired-cmd-create-temp-image-options "convert")
    (add-to-list 'image-dired-cmd-rotate-thumbnail-options "mogrify"))
  :custom (image-dired-thumbnail-storage 'standard-large))

;; Addtional syntax highlighting for dired
(use-package diredfl :ensure :after dired
  :config
  (custom-set-faces '(diredfl-dir-heading ((t :background "#ffc0cb" :foreground "#2a0b9a"))))
  :hook (dired-mode . diredfl-mode))

;; Testing - Drop-in replacement for find-dired
(use-package fd-dired :ensure :after dired
  :bind (:map dired-mode-map ("C-c C-f" . fd-dired)))

(use-package dired
  :after evil-collection general
  :custom
  (dired-listing-switches "-AGhlv --group-directories-first --time-style=long-iso")
  (dired-recursive-deletes 'always)
  ;; moves to trash according to XDG - .local/share/.Trash
  (delete-by-moving-to-trash t)
  ;;(put 'dired-find-alternate-file 'disabled nil)
  ;;(define-key dired-mode-map (kbd "RET") #'dired-find-alternate-file)
  ;; instead of above, since ver28 simply:
  (dired-kill-when-opening-new-dired-buffer t)
  (all-the-icons-dired-monochrome nil)
  (dired-dwim-target t) ;; copy between vertical windows  
  :init (defun dired-here () (interactive) (dired "."))
  :general ("C-x C-d" 'dired-here 
            "<leader>d" 'dired-jump)
  :config
  (general-def '(motion normal) :keymaps dired-mode-map "<mouse-2>" 'dired-mouse-find-file)
  (put 'all-the-icons-dired-mode 'safe-local-variable #'listp) ;; safe var property
  (evil-collection-define-key 'motion 'dired-mode-map "/" 'dired-narrow-fuzzy)
  (evil-collection-define-key 'normal 'dired-mode-map "l" 'dired-open-file)
  (evil-collection-define-key 'normal 'dired-mode-map "h" 'dired-up-directory)
  ;;(evil-collection-define-key 'normal 'dired-mode-map (kbd "M-RET") 'dired-open-xdg)
  (evil-collection-define-key 'motion 'dired-mode-map (kbd "C-<return>") 'dired-open-xdg)
  (evil-collection-define-key 'normal 'dired-mode-map "q" 'kill-this-buffer)
  (evil-collection-define-key 'normal 'image-dired-thumbnail-mode-map (kbd "M-<SPC>") 'image-dired-display-next-thumbnail-original)
  (evil-collection-define-key 'normal 'image-dired-thumbnail-mode-map (kbd "M-S-<SPC>") 'image-dired-display-previous-thumbnail-original)
  (evil-collection-define-key 'normal 'image-dired-thumbnail-mode-map (kbd "U") 'image-dired-unmark-all-marks)
  (run-with-idle-timer 1 nil #'(lambda ()
                                 (general-def '(motion normal) dired-mode-map "SPC" (general-simulate-key "<leader>"))
                                 ))
  (with-eval-after-load 'evil-collection-dired
    (with-eval-after-load 'dired-subtree
      ;; no way to control order of with-eval-after-load in evil-collection-dired+dired-subtree
      (run-with-idle-timer 1 nil #'(lambda () (general-def '(motion normal visual) dired-mode-map "M-j" nil "M-k" nil)))))
  
  (evil-define-key 'normal dired-mode-map (kbd "f") dired-filter-map)
  ;; following stuff is disabled due to performance concerns
  ;;(require 'treemacs-icons-dired) ; all-the-icons are better
  ;;(require 'dired-du) ; performance
      ;;; this one produces "Permission denied" on listing in Win10 with JUNCTION folders
  ;;(add-hook 'dired-mode-hook #'dired-du-mode)
  ;;(require 'dired-collapse) ; performance
  :hook
  (dired-mode . dired-utils-format-information-line-mode)
  (evil-collection-setup . (lambda (mode map)
                             (when (eq mode 'dired)
                               (message "dired evil-collection setup hook")
                               (evil-collection-define-key
                                 'normal 'dired-mode-map "." 'dired-hide-dotfiles-mode))))
  (dired-mode . dired-async-mode)
  (dired-mode . dired-hide-details-mode)
  )

(use-package dirvish
  :disabled
  :ensure
  :after dired
  ;; otherwise it failes to initialize
  :init (set-frame-parameter nil 'dirvish--hash (make-hash-table :test 'equal))
  :config
  ;; Override dired with dirvish globally
  ;;(dirvish-override-dired-mode)
  ;; Enable file preview when narrowing files in minibuffer.
  ;; This feature only support `vertico/selectrum' for now.
  ;;(dirvish-peek-mode)
  :bind
  (:map global-map
        ("C-x D" . dirvish-dired)
        ("C-x C-d" . dirvish))
  ;; (:map dired-mode-map
  ;;       ("SPC" . dirvish-show-history)
  ;;       ([remap drivish-yank] . )
  ;;       ([remap mode-line-other-buffer] . dirvish-other-buffer)
  ;;       )
  )
#+end_src

** grep
#+begin_src emacs-lisp
(use-package ag
  :ensure
  :custom
  (ag-highlight-search t)
  (ag-reuse-buffers t)
  :config
  (add-to-list 'ag-arguments "--word-regexp"))

(use-package ripgrep :ensure)
(use-package flx :ensure)
(use-package wgrep :ensure)
(use-package wgrep-ag :ensure)
(use-package fzf :ensure :unless (eq system-type 'windows-nt))

;;Nice pure lisp find-grep replacement - works on windows well
(when (eq system-type 'windows-nt)
  (use-package xah-find
    :after evil
    :ensure
    :general (:states '(normal motion) :keymaps 'xah-find-output-mode-map "RET" 'xah-find--jump-to-place)))
#+end_src

** projectile

#+begin_src emacs-lisp
(use-package projectile
  :ensure
  :after evil
  :init
  (setq projectile-use-git-grep t)
  (evil-define-key 'motion global-map (kbd "<leader>p") 'hydra-projectile/body)
  (defun projectile-mini-mode-line ()
    "Minimal projectile mode-line"
    projectile-mode-line-prefix)
  :bind-keymap ("C-c p" . projectile-command-map)
  :custom
  (projectile-completion-system 'ivy)
  ;;(projectile-project-search-path (list "~/Documents"))
  ;; (projectile-mode-line-function #'projectile-default-mode-line)
  (projectile-mode-line-function #'projectile-mini-mode-line)
  (projectile-mode-line-prefix "") ;; " P"
  :functions (projectile-project-name)
  :commands (hydra-projectile/body)
  :pretty-hydra
  (hydra-projectile
   (:hint nil :color teal :quit-key "q" :title (with-faicon "rocket" "Projectile" 1 -0.05))
   ("Buffers"
    (("b" counsel-projectile-switch-to-buffer "list")
     ("k" projectile-kill-buffers "kill all")
     ("S" projectile-save-project-buffers "save all"))
    "Find"
    (("d" counsel-projectile-find-dir "directory")
     ("F" projectile-recentf "recent files")
     ("B" projectile-list-buffers "buffers")
     ("D" projectile-dired "dired")
     ("g" counsel-projectile-find-file-dwim "file dwim")
     ("f" counsel-projectile-find-file "file")
     ("p" counsel-projectile-switch-project "project"))
    "Other"
    (("i" projectile-invalidate-cache "reset cache")
     ("x" projectile-remove-known-project "remove known project")
     ("z" projectile-cache-current-file "cache current file")
     ("X" projectile-cleanup-known-projects "cleanup known projects"))
    "Search"
    (("r" projectile-replace "replace")
     ("o" projectile-multi-occur "occur")
     ("R" projectile-replace-regexp "regexp replace")
     ("sr" counsel-projectile-grep "grep")
     ("sa" counsel-projectile-ag "ag")
     ("sg" counsel-projectile-rg "rg")
     ("ss" counsel-rg "search")))))

(use-package counsel-projectile
  :functions counsel-projectile-mode
  :ensure
  :demand :after (projectile counsel)
  :config (counsel-projectile-mode))
#+end_src

** treemacs

#+begin_src emacs-lisp
(use-package treemacs-evil :after treemacs evil :ensure)
(use-package treemacs-projectile :ensure :after treemacs projectile)
(use-package treemacs-magit :ensure :after treemacs magit)
(use-package treemacs-all-the-icons :ensure :after treemacs all-the-icons)
(use-package treemacs-nerd-icons :ensure :after treemacs nerd-icons)
(use-package treemacs-tab-bar :ensure :demand :after tab-bar treemacs)
(use-package treemacs
  :ensure
  :after evil
  :init (evil-define-key 'motion global-map (kbd "<leader>t") 'treemacs) ;;treemacs-add-and-display-current-project ;; this will add projectile project automatically
  :config
  (require 'treemacs-themes)
  (require 'treemacs-icons)
  (require 'treemacs-all-the-icons)
  (require 'treemacs-nerd-icons)
  (require 'treemacs-evil)
  (require 'treemacs-projectile)
  (require 'treemacs-magit)
  (treemacs-load-theme 'nerd-icons)
  ;; (treemacs-follow-mode -1) ;; kills remote mounts
  (treemacs-follow-mode 1)
  (treemacs-project-follow-mode) ;; this is what I need - treemacs buffer show 1 project exclusively and follows
  ;; (treemacs-resize-icons 15)
  (general-def treemacs-mode-map "M-l" nil "M-h" nil)
  :custom
  (treemacs-follow-after-init t)
  (treemacs-width 33)
  (treemacs-wide-toggle-width 67)
  :functions (treemacs-follow-mode treemacs-load-theme)
  :commands treemacs-modify-theme
  ;; :custom
  ;; (treemacs-fringe-indicator-mode t)
  )
#+end_src

** bookmarks
#+begin_src emacs-lisp :tangle no
(customize-set-variable 'bookmark-default-file "~/documents/org/bookmarks.eld")

;; is used by info+ (at least)
(use-package bookmark+
  :unless (eq system-type 'windows-nt)
  ;; :disabled t
  :quelpa (bookmark+ :fetcher wiki
                     :files
                     ("bookmark+.el"
                      "bookmark+-mac.el"
                      "bookmark+-bmu.el"
                      "bookmark+-1.el"
                      "bookmark+-key.el"
                      "bookmark+-lit.el"
                      "bookmark+-doc.el"
                      "bookmark+-chg.el"))
  :defer 2
  :custom
  (bmkp-crosshairs-flag nil) ;; ugly
  ) 

(use-package crosshairs :quelpa (crosshairs :fetcher wiki))
(use-package col-highlight :quelpa (col-highlight :fetcher wiki))
(use-package hl-line+ :quelpa (hl-line+ :fetcher wiki))
#+end_src

* * *frames & windows & buffers & tabs
** frame
#+begin_src emacs-lisp
(use-package frame
  :demand
  :config
  (size-indication-mode nil)
  (cond
   ((eq window-system 'x)
    (fringe-mode '16))
   ((eq window-system 'pgtk)
    (fringe-mode '12))
   ;; (t  ; This covers both 'nil' (terminal) and any other unexpected values
   ;;  (fringe-mode 0)
   ;;  (message "Disabling fringe for terminal or unknown window system"))
   )

  (blink-cursor-mode -1) ;; disabled in favor of pixel-scroll speed
  (menu-bar-mode -1)
  (tool-bar-mode -1)
  ;; (tooltip-mode -1)
  :custom
  (fringe-styles '(
                   ("default" . 24)
                   ("no-fringes" . 0)
                   ("right-only" . (0 . 24))
                   ("left-only" . (24 . 0))
                   ("half-width" . (12 . 12))
                   ("minimal" . (6 . 6))
                   ))

  ;; ~ fix this
  ;; (modify-all-frames-parameters
  ;;  '((right-divider-width . 4)
  ;;    ;; (internal-border-width . 4)
  ;;    ))
  ;; ;;(face-spec-reset-face face)
  ;; (add-hook 'after-make-frame-functions
  ;;           #'(lambda () 

  ;;               ;; (set-face-foreground
  ;;               ;;  'window-divider-last-pixel
  ;;               ;;  (face-attribute 'default :background))
  ;;               (set-face-foreground
  ;;                'window-divider-first-pixel
  ;;                (face-attribute 'default :background))
  ;;               ;; (set-face-foreground 'window-divider "#504945")
  ;;               ))

  )

;; :EXPERIMENT:
(use-package modern-fringes
  :ensure
  :config
  (modern-fringes-mode)
  (modern-fringes-invert-arrows)
  )
#+end_src

** tab-bar

#+name: tab-bar
#+begin_src emacs-lisp
(use-package tab-bar
  :demand
  :after evil
  :functions (my/name-tab-by-project-or-default)
  :commands (hydra-tab/body my/init-my-tabs tab-bar-select-tab)
  :general ('motion global-map "<leader><tab>" 'hydra-tab/body)
  :init
  (defun my/init-my-tabs ()
    "Initialize usual tabs in case desktop save was broken."
    (interactive)
    (tab-bar-history-mode); it doesn't really work, see winner-mode and fix this one
    (tab-rename "🕐 org")
    ;;(tab-group "personal")
    (tab-new)
    (tab-rename "🖮 emacs")
    ;; (tab-group "personal")
    (tab-new)
    (tab-rename "🚀 system")
    ;; (tab-group "personal")
    (tab-new)
    (tab-rename "🍛 dk")
    ;; (tab-group "work")
    (tab-new)
    (tab-rename "👷 work")
    ;; (tab-group "work")
    )
  :init
  ;; Experimental
  (define-minor-mode buffer-tab-assign-mode
    "Enable automatic buffer move to dedicated tab (per project)."
    :lighter "" ;; " B"
    :global t
    (if buffer-tab-assign-mode
        (progn (require 'projectile) ;; todo - package this stuff
               (add-hook 'window-configuration-change-hook #'assign-buffer-to-tab-by-project)
               ;; (assign-buffer-to-tab-by-project)
               )
      (remove-hook 'window-configuration-change-hook #'assign-buffer-to-tab-by-project)
      ))
  ;; with-eval-after-load 'projectile
  (defvar buffer-assignment-in-progress nil
    "Flag is used to avoid recursive window-configuration-change-hook calls")
  (defcustom buffer-assignment-tab-alist
    '(("\\*scratch\\*" . "emacs")
      (".*\\*helpful.*" . "emacs")
      ("provision.org" . "configs")
      (".*\\*Backtrace.*" . "emacs")
      (".*\\*Help.*" . "emacs")
      (".*\\*w3m\\*" . "w3m")
      ("\\*info\\*" . "emacs")
      ("\\*Messages\\*" . "emacs"))
    "Assignment of buffers to tabs based on regexp.")
  ;; (defcustom buffer-assignment-tab-func )
  (defun buffer-assignment-tab-func (buffer-name)
    "Return name of the tab to assign buffer to."
    ;; (cl-loop for (key . value) in buffer-assignment-tab-alist
    ;;          collect (cons value key))
    (let ((tab-name (projectile-project-name)))
      (dolist (x buffer-assignment-tab-alist)
        (when (string-match (car x) (buffer-name))
          (setq tab-name (cdr x))))
      tab-name))
  ;; WIP
  (require 'cl-lib)
  (defun open-all-assigned-buffers ()
    (interactive)
    "Open all assigned buffers in tab-line"
    (let* ((next-buffers (window-next-buffers))
           (prev-buffers (window-prev-buffers))
           (current-tab-name (cdr (assq 'name (tab-bar--current-tab))))
           (all-buffers (projectile-project-buffers) ;;(buffer-list)
                        )
           (new-next-buffers
            (append next-buffers
                    (cl-remove-if-not
                     #'(lambda (el)
                         (string= current-tab-name (buffer-assignment-tab-func (buffer-name el))))
                     (cl-set-difference all-buffers prev-buffers)))))
      (set-window-next-buffers nil next-buffers)
      (force-mode-line-update)
      ))
  (defun assign-buffer-to-tab-by-project ()
    "Experimental: move buffers to dedicated tabs (workspaces) per project."
    (interactive)
    (when tab-bar-mode
      (let* ((buffer (window-buffer))
             (buffer-name (buffer-name buffer))
             (is-lame-buffer (string-match "\\ \\*" (buffer-name buffer))))
        ;; (when is-lame-buffer (message "lame buffer %s" (buffer-name (window-buffer))))
        (when (not is-lame-buffer)
          ;; (when buffer-assignment-in-progress (message "debug: buffer-assignment-in-progress"))
          (when (not buffer-assignment-in-progress)
            (let ((buffer-assignment-in-progress t))
              (let (window-configuration-change-hook)
                (let ((current-tab-name (cdr (assq 'name (tab-bar--current-tab))))
                      (tab-name (buffer-assignment-tab-func buffer-name)))
                  ;; (when (string= current-tab-name project-name) (message "debug: buffer already belongs to %s" current-tab-name))
                  (when (not (string= current-tab-name tab-name))
                    (quit-window) ;; bury?
                    (when (not (tab-bar--tab-index-by-name tab-name))
                      (let ((tab-bar-new-tab-choice buffer-name)) ;; todo - debug, this does not work
                        (message (format "creating new tab %s" tab-name))
                        (tab-bar-new-tab)
                        (tab-bar-rename-tab tab-name)
                        ;; stupid, but tab-bar-show=1 lags without this
                        (run-with-idle-timer 1 nil #'tab-bar--update-tab-bar-lines)
                        ;; todo - do proper cleanup without dangling prev buffer in new tab
                        (set-window-prev-buffers nil nil)
                        (set-window-next-buffers nil nil)
                        ))
                    (tab-bar-select-tab-by-name tab-name)
                    ;; (message "debug: moving buffer %s to tab %s" buffer project-name)
                    (switch-to-buffer buffer)
                    )))
              (run-hooks 'window-configuration-change-hook)))))))
  (bind-key "M-i" 'assign-buffer-to-tab-by-project)
  (if is-android
      (progn
        (tab-bar-mode -1))
    (progn
      ;; (display-time-mode 1)
      (tab-bar-mode 1)
      (buffer-tab-assign-mode 1)
      ;; (tab-bar-rename-tab "default")
      ;; (tab-bar-rename-tab (projectile-project-name))
      ))
  ;; (setq tab-bar-tab-name-function #'name-tab-by-project-or-default)
  ;; (defun name-tab-by-project-or-default ()
  ;;   "Return project name if in a project, or default tab-bar name if not.
  ;; The default tab-bar name uses the buffer name."
  ;;   (let ((project-name (projectile-project-name)))
  ;;     (if (string= "-" project-name)
  ;;         (tab-bar-tab-name-current)
  ;;       (projectile-project-name))))

  ;; :init (require 'projectile)
  ;; (customize-set-variable 'tab-bar-tab-name-function #'projectile-project-name)

  :config
  (custom-set-faces
   '(tab-bar ((t :foreground "#101823" :background "#fdfae8")))
   '(tab-bar-tab ((t :box (:line-width 1 :style pressed-button))))
   '(tab-bar-tab-inactive ((t :background "#e2e6d0"))))
  ;; WIP: migrate sirent-tab to simple code here

  ;; WIP
  (defface tab-bar-tab-org '((t :inherit tab-tab-tab :foreground "PaleVioletRed1")) "face for org tab-bar tab")
  (defun my/tab-bar-colorize (tab)
    (message "tab-bar-name=%s" (alist-get 'name tab))
    (if (string-match-p (regexp-quote "org") (alist-get 'name tab))
        'tab-bar-tab-org
      (tab-bar-tab-face-default tab)))
  (setq tab-bar-tab-face-function #'my/tab-bar-colorize)
  

  ;; WIP
  ;; (require 'powerline)

  ;; (defvar my/tab-bar-height 36)
  ;; (defvar my/tab-bar-left (powerline-wave-right 'tab-bar 'tab-bar my/tab-bar-height))
  ;; (defvar my/tab-bar-right (powerline-wave-left 'tab-bar 'tab-bar my/tab-bar-height))
  ;; (defun my/tab-bar-tab-name-format-function (tab i)
  ;;   (powerline-render (list
  ;;                      my/tab-bar-left
  ;;                      ;; (format " %s  " (buffer-name buffer))
  ;;                      ;; (tab-bar-tab-name-format-default tab i)
  ;;                      (concat (if tab-bar-tab-hints (format "%d " i) "")
  ;;                              (alist-get 'name tab))
  ;;                      my/tab-bar-right)))
  ;; (setq tab-bar-tab-name-format-function #'my/tab-bar-tab-name-format-function)
  ;; (setq tab-bar-tab-name-format-function #'tab-bar-tab-name-format-default)

  
  (defun tab-bar-custom-format ()
    ;;https://github.com/jimeh/.emacs.d/blob/c845af831690d1ab575b691020fbe91ce6435647/modules/workspaces/siren-tab-bar.el#L119-L138

    (defgroup siren-tab-bar nil
      "Siren specific tweaks to tar-bar-mode."
      :group 'tab-bar)

    (defface siren-tab-bar-tab
      `((t
         :inherit 'tab-bar-tab
         :inverse-video t
         ;; :foreground ,(face-attribute 'font-lock-keyword-face :foreground nil t)
         ;; :foreground ,(face-attribute 'font-lock-constant-face :foreground nil t)
         :weight bold
         ;; :foreground "#e4a2f4"
         :foreground "#5d6081" ;;#3d4071
         ))
      "Face for active tab in tab-bar."
      :group 'siren-tab-bar)

    (defface siren-tab-bar-tab-hint
      '((t :inherit 'siren-tab-bar-tab
           :weight bold
           :foreground "#5d6081"))
      "Face for active tab hint in tab-bar."
      :group 'siren-tab-bar)

    (defface siren-tab-bar-tab-inactive
      '((t :inherit 'tab-bar-tab-inactive
           :foreground "#3d4071"
           ;; :italic t
           ))
      "Face for inactive tab in tab-bar."
      :group 'siren-tab-bar)

    (defface siren-tab-bar-tab-hint-inactive
      `((t :inherit 'siren-tab-bar-tab-inactive
           :weight bold
           :foreground ,(face-attribute 'tab-bar-tab-inactive :foreground nil t)))
      "Face for inactive tab hint in tab-bar."
      :group 'siren-tab-bar)

    (defun siren-tab-bar-tab-name-format-default (tab i)
      (let* ((current-p (eq (car tab) 'current-tab))
             (tab-face (if current-p
                           'siren-tab-bar-tab
                         'siren-tab-bar-tab-inactive))
             (hint-face (if current-p
                            'siren-tab-bar-tab-hint
                          'siren-tab-bar-tab-hint-inactive)))
        (concat
         ;; (powerline-render
         ;;  (list
         ;;   my/tab-bar-left
         ;;   " n " 
         ;;   ;; (format " %s  " (buffer-name buffer))
         ;;   ;; (tab-bar-tab-name-format-default tab i)
         ;;   ;; (concat (if tab-bar-tab-hints (format "%d " 1) "")
         ;;   ;;         (alist-get 'name (tab-bar--current-tab)))
         ;;   my/tab-bar-right))
         (propertize (if tab-bar-tab-hints
                         (format "  %d:" i)
                       "  ")
                     'face hint-face)

         (propertize (concat
                      (alist-get 'name tab)
                      (or (and tab-bar-close-button-show
                               (not
                                (eq
                                 tab-bar-close-button-show
                                 (if current-p
                                     'non-selected
                                   'selected)))
                               tab-bar-close-button)
                          "")
                      "  ")
                     'face tab-face))))

    (setq tab-bar-tab-name-format-function #'siren-tab-bar-tab-name-format-default))

  ;; again, order of defface matters
  (run-with-idle-timer 1 nil #'tab-bar-custom-format)


  ;; conflicts with highlight-symbol
  ;; :general ("M-n" 'tab-bar-switch-to-next-tab "M-p" 'tab-bar-switch-to-prev-tab)
  :custom
  ((tab-bar-tab-hints t) ; t
   (tab-bar-tab-name-function #'(lambda () "emacs")) ;; experiment
   (tab-bar-auto-width nil)
   (tab-bar-show 1)
   (tab-bar-select-tab-modifiers '(meta))
   (tab-bar-format '(tab-bar-format-menu-global tab-bar-format-tabs-groups tab-bar-separator tab-bar-format-align-right tab-bar-format-global))
   (tab-bar-history-limit 30)
   (tab-bar-close-button-show nil)
   (tab-bar-close-button-show nil)
   (display-time-use-mail-icon t)
   (display-time-mail-directory nil); "~/.mail/gmail/Inbox/new" ; using mu4e
   (display-time-day-and-date nil))
  :pretty-hydra
  (hydra-tab
   (:hint nil :color amaranth :quit-key "q" :title (with-material "tab" "Tab" 1 -0.05))
   ("Tabs"
    (("<tab>" tab-bar-select-tab-by-name "Switch tab")
     ("n" tab-bar-new-tab "New tab")
     ("j" tab-next "Next tab")
     ("k" tab-previous "Previous tab")
     ("g" tab-group "Group")
     ("m" tab-move "Move")
     ("r" tab-bar-rename-tab "Rename tab")
     ("R" tab-bar-rename-tab-by-name "Rename tab by name")
     ("d" tab-bar-close-tab "Close tab")
     ("D" tab-bar-close-tab-by-name "Close tab by name")
     ("1" tab-bar-close-other-tabs "Close other tabs"))))
  )
#+end_src
** tab-line

#+name: tab-line
#+begin_src emacs-lisp
(use-package tab-line
  ;;:defer 0.5
  :bind
  ("M-l" . tab-line-next-tab-cycle)
  ("M-h" . tab-line-prev-tab-cycle)
  ;; I want to hide window if this is the last tab shown (see set-last-tab-window-quit-restore)
  ("M-j" . quit-window)
  ("M-k" . quit-window-kill-buffer)
  ;; todo - this fails here cause term is not loaded yet
  ;;(global-set-key (kbd "<s-left>") 'tab-bar-history-back)
  ;;(global-set-key (kbd "<s-right>") 'tab-bar-history-forward)
  :bind*
  ("M-<left>" . evil-jump-backward) ;; using this with libinput-gestures
  ("M-<right>" . evil-jump-forward)
  ("C-S-<tab>" . tab-line-prev-tab-cycle) ;; using this with libinput-gestures
  ("C-S-<iso-lefttab>" . tab-line-prev-tab-cycle) 
  ("C-<tab>" . tab-line-next-tab-cycle)
  :init
  (global-tab-line-mode)
  (defun quit-window-kill-buffer ()
    "Simply quit-window with killing current buffer"
    (interactive)
    (quit-window t))
  (defun tab-line-next-tab-cycle ()
    "Fixing original tab-line-switch-to-next-tab to properly work cycling
and preserving order of tabs. This implementation would cycle through
tabs visible in the window currently, without switching to buried/other tabs."
    (interactive)
    (let* ((tabs (funcall tab-line-tabs-function))
           (pos (seq-position
                 tabs (current-buffer)
                 (lambda (tab buffer)
                   (if (bufferp tab)
                       (eq buffer tab)
                     (eq buffer (cdr (assq 'buffer tab)))))))
           (new-pos (if pos
                        (if (<= (length tabs) (1+ pos))
                            0 ;; cycle to the first tab
                          (1+ pos))))
           (tab (if (= new-pos 0) (car tabs) (nth new-pos tabs)))
           (buffer (if (bufferp tab) tab (cdr (assq 'buffer tab)))))
      (when (bufferp buffer)
        (if (= new-pos 0)
            (switch-to-buffer buffer)
          (switch-to-next-buffer)))))
  (defun tab-line-prev-tab-cycle ()
    "See `tab-line-next-tab-cycle'."
    (interactive)
    (let* ((tabs (funcall tab-line-tabs-function))
           (pos (seq-position
                 tabs (current-buffer)
                 (lambda (tab buffer)
                   (if (bufferp tab)
                       (eq buffer tab)
                     (eq buffer (cdr (assq 'buffer tab)))))))
           (last-pos (1- (length tabs)))
           (new-pos (if pos
                        (if (<= pos 0)
                            last-pos;; cycle to the last tab
                          (1- pos))))
           (tab (nth new-pos tabs))
           (buffer (if (bufferp tab) tab (cdr (assq 'buffer tab)))))
      (when (bufferp buffer)
        (if (= new-pos last-pos)
            (switch-to-buffer buffer)
          (switch-to-prev-buffer)))))


  ;; WIP - trying to preserve ordering of tabs when switching prev from 1 buffer in line

  ;; (defun tab-line-prev-tab-cycle1 ()
  ;;   "See `tab-line-next-tab-cycle'."
  ;;   (interactive)
  ;;   (let* ((tabs (funcall tab-line-tabs-function))
  ;;          (pos (seq-position
  ;;                tabs (current-buffer)
  ;;                (lambda (tab buffer)
  ;;                  (if (bufferp tab)
  ;;                      (eq buffer tab)
  ;;                    (eq buffer (cdr (assq 'buffer tab)))))))
  ;;          (last-pos (1- (length tabs)))
  ;;          (new-pos (if pos
  ;;                       (if (<= pos 0)
  ;;                           last-pos;; cycle to the last tab
  ;;                         (1- pos))))
  ;;          (tab (nth new-pos tabs))
  ;;          (prev-buffer (if (bufferp tab) tab (cdr (assq 'buffer tab))))
  ;;          (window (selected-window))
  ;;          (current-buffer (window-buffer window))
  ;;          (new-prev-buffers (delq prev-buffer (window-prev-buffers window)))
  ;;          (new-next-buffers (append (list current-buffer) (window-next-buffers window)))
  ;;          )
  ;;     (when (bufferp prev-buffer)
  ;;       (if (= new-pos last-pos)
  ;;           (progn
  ;;             (switch-to-buffer prev-buffer)
  ;;             (set-window-next-buffers new-next-buffers)
  ;;             (set-window-prev-buffers new-prev-buffers))
  ;;         (switch-to-prev-buffer)))))




  
  ;; :custom-face
  ;; (tab-line-highlight ((t (:inherit (tab-line-tab))))) ;; mouseover
  ;; (tab-line-tab-current ;; active tab in current window
  ;;  ((t (:extend t :background "#504945" :foreground "#fdf4c1" :weight bold :underline t ;:box '(:line-width (1 . 1) :color "grey75" :style released-button)
  ;;               ))))
  ;; (tab-line-tab-inactive ;; inactive tab
  ;;  ((t (:foreground "#fdf4c1" :background "#1d2021"))))
  ;; (tab-line-tab ((t (:extend t :background "#504945" :foreground "#fdf4c1")))) ;; active tab in another window
  ;; (tab-line ((t (:foreground "#fdf4c1" :background "#1d2021" :distant-foreground "gray20")))) ;; background behind tabs

  :config
  (defun my/tab-line-set-faces ()
    (custom-set-faces
     '(tab-line ((t (
                     :foreground "#1d2021"
                     :background "#fdfae8"
                     ;; :background "#f8f7ef"
                     ;; :background "#ede4c1"
                     ;; :distant-foreground "#fdf4c1" :distant-foreground 'unspecified
                     ;; :family "Fira Sans Condensed"
                     :box (:line-width (-1 . 1) :style released-button)))))
     '(tab-line-tab ((t (
                         :inherit 'tab-line
                         :background "#ede4c1"
                         ;; :background "#fdfae8"
                         :box nil))))
     '(tab-line-tab-inactive ((t (
                                  :inherit 'tab-line-tab
                                  ;; :background "#fdfae8"
                                  :background "#ede4c1"))))
     ;; mouseover
     '(tab-line-highlight ((t (
                               :inherit 'tab-line-tab
                               ;; :foreground 'unspecified
                               :box t
                               :background "#ede4c1"
                               ))))
     '(tab-line-tab-modified ((t (
                                  :inherit 'tab-line-tab
                                  :slant italic
                                  :foreground: "#959591"))))
     '(tab-line-tab-current ((t (
                                 :inherit 'tab-line-tab
                                 :background "#fdfae8"
                                 :foreground "#1d2021"
                                 :weight bold
                                 :inverse-video t :box nil
                                 ;;:underline t
                                 ;; :box '(:line-width (1 . 1) :style released-button)
                                 )))))
  
    ;; WIP - trying to colorize tabs
    ;; (defface tab-line-tab-non-file '((t :inherit tab-line-tab-inactive :foreground "grey65")) "face for non-file tabs")
    ;; (defface tab-line-tab-org-mode '((t :inherit tab-line-tab-inactive :foreground "LightGoldenrod1")) "face for org-mode tabs")
    ;; (defface tab-line-tab-term-mode '((t :inherit tab-line-tab-inactive :foreground "LightSlateBlue")) "face for term-mode tabs")
    ;; (defface tab-line-tab-prog-mode '((t :inherit tab-line-tab-inactive :foreground "CadetBlue1")) "face for prog-mode tabs")
    ;; (defface tab-line-tab-inactive-dired '((t :inherit tab-line-tab-inactive :foreground "DarkOrange")) "face for dired tab-line tabs")
    ;; (defface tab-line-tab-inactive-agenda '((t :inherit tab-line-tab-inactive :foreground "PaleVioletRed1")) "face for org agenda tab-line tabs")
    ;; light-theme
    (defface tab-line-tab-non-file '((t :inherit tab-line-tab-inactive :foreground "#227324")) "face for non-file tabs")
    (defface tab-line-tab-org-mode '((t :inherit tab-line-tab-inactive :foreground "#8e5d18")) "face for org-mode tabs")
    (defface tab-line-tab-term-mode '((t :inherit tab-line-tab-inactive :foreground "#6556b9")) "face for term-mode tabs")
    (defface tab-line-tab-prog-mode '((t :inherit tab-line-tab-inactive :foreground "#3969a6")) "face for prog-mode tabs")
    (defface tab-line-tab-inactive-dired '((t :inherit tab-line-tab-inactive :foreground "#773322")) "face for dired tab-line tabs")
    (defface tab-line-tab-inactive-agenda '((t :inherit tab-line-tab-inactive :foreground "#885533")) "face for org agenda tab-line tabs")
    (defun my/tab-line-colorize (tab _tabs face buffer-p _selected-p)
      ;; TODO - use some 'case' syntax here
      (when (not (buffer-file-name tab))
        (setf face `(:inherit (tab-line-tab-non-file ,face))))
      (when (and buffer-p (eq (buffer-local-value 'major-mode tab) 'term-mode))
        (setf face `(:inherit (tab-line-tab-term-mode ,face))))
      (when (and buffer-p (eq (buffer-local-value 'major-mode tab) 'dired-mode))
        (setf face `(:inherit (tab-line-tab-inactive-dired ,face))))
      (when (and buffer-p (provided-mode-derived-p (buffer-local-value 'major-mode tab) 'prog-mode))
        (setf face `(:inherit (tab-line-tab-prog-mode ,face))))
      (when (and buffer-p (eq (buffer-local-value 'major-mode tab) 'org-mode))
        (setf face `(:inherit (tab-line-tab-org-mode ,face))))
      (when (and buffer-p (eq (buffer-local-value 'major-mode tab) 'org-agenda-mode))
        (setf face `(:inherit (tab-line-tab-inactive-agenda ,face))))
      face)
    ;; (when is-android
    ;;   (custom-set-faces
    ;;    (backquote
    ;;     (tab-line-tab-current
    ;;      ((t (:background "#504945" :underline '(:color foreground-color :style line))))))))
    (setq tab-line-tab-face-functions '(my/tab-line-colorize tab-line-tab-face-modified tab-line-tab-face-special))
  )
  ;; no idea - it doesn't work when set right away
  (add-hook
   'after-init-hook
   #'(lambda ()
       (run-with-idle-timer
        1 nil #'(lambda () (my/tab-line-set-faces)))))

  ;; https://amitp.blogspot.com/2020/06/emacs-prettier-tab-line.html
  ;; WIP
  (defun tab-line-wave ()
    (interactive)
    (require 'powerline)
    (defvar my/tab-height 36)
    (defvar my/tab-left (powerline-wave-right 'tab-line nil my/tab-height))
    (defvar my/tab-right (powerline-wave-left nil 'tab-line my/tab-height))
    (defun my/tab-line-tab-name-buffer (buffer &optional _buffers)
      (powerline-render (list my/tab-left
                              ;; (format " %s  " (buffer-name buffer))
                              (tab-line-tab-name-truncated-buffer buffer _buffers)
                              my/tab-right)))
    (setq tab-line-tab-name-function #'my/tab-line-tab-name-buffer)
    )
  (unless is-android
    (run-with-idle-timer 1 nil #'tab-line-wave)
  )

  :custom
  ((tab-line-new-button-show nil)
   (tab-line-close-button-show nil)
   (tab-line-tab-name-function #'tab-line-tab-name-truncated-buffer)
   (tab-line-tab-name-truncated-max 30)
   ;; there is a problem with cycling logic because of internal switch-to-buffer vs switch-to-next-buffer and ordering of buffers being changed
   ;; (tab-line-tabs-function #'(lambda () (tab-line-tabs-window-buffers)))
   ;; experimenting - M-h/M-l would cycle
   ;; (tab-line-switch-cycling t)
   (tab-line-tabs-function #'tab-line-tabs-window-buffers)
   )
   ;;(tab-line-tabs-function #'tab-line-tabs-buffer-groups)
   ;;tab-line-tab-face-group tab-line-tab-face-inactive-alternating)
  )
#+end_src

** windows & buffers
#+begin_src emacs-lisp
(use-package ace-window :ensure :after avy)

(use-package frame-fns :quelpa (frame-fns :fetcher wiki))

(use-package frame-cmds :quelpa (frame-cmds :fetcher wiki))

(use-package zoom-frm
  :after frame-fns frame-cmds
  :commands (zoom-frm-in zoom-frm-out)
  :quelpa (zoom-frm :fetcher wiki))

(use-package golden-ratio
  :ensure :diminish
  :after which-key
  :init (golden-ratio-mode)
  :custom
  (golden-ratio-adjust-factor 1.40)
  (golden-ratio-inhibit-functions
   '((lambda () which-key--pages-obj)
     (lambda () (and (fboundp 'multi-term-dedicated-window-p) (multi-term-dedicated-window-p)))
     (lambda () (and (boundp 'ediff-this-buffer-ediff-sessions) (or ediff-this-buffer-ediff-sessions ediff-diff-buffer)))
     ))
  (golden-ratio-exclude-buffer-regexp '(
                                        ;;"lsp-help"
                                        "lsp-ui-imenu" "lsp-diagnostics"))
  (golden-ratio-exclude-modes '("ediff-mode" "dirvish-mode" "lsp-ui-flycheck-list"
                                "ranger-mode" "reb-mode" "treemacs-mode" "minibuffer-mode")))

(use-package popwin
  :ensure :disabled
  :defer 0.1
  ;;:config
  ;;(popwin-mode) ; sometimes it annoys me
  )

(use-package windmove
  ;; :bind*
  ;; (("M-H" . windmove-left)
  ;;  ("M-J" . windmove-down)
  ;;  ("M-K" . windmove-up)
  ;;  ("M-L" . windmove-right)
  ;;  ("C-S-h" . windmove-swap-states-left)
  ;;  ("C-S-j" . windmove-swap-states-down)
  ;;  ("C-S-k" . windmove-swap-states-up)
  ;;  ("C-S-l" . windmove-swap-states-right))
  :config
  ;; no way to override this in other way right now - this gets remapped in org mode from outline mode which is changed by evil-collection
  (add-hook 'evil-collection-setup-hook
            #'(lambda (mode map)
                (when (eq mode 'outline)
                  (evil-collection-define-key 'normal 'outline-mode-map
                    (kbd "M-h") nil
                    (kbd "M-j") nil
                    (kbd "M-k") nil
                    (kbd "M-l") nil
                    )))))

;; using it until I fix tab-bar-history
(use-package winner
  :defer 0.5
  :init
  (winner-mode 1)
  :bind
  ("M-P" . winner-undo)
  ("M-N" . winner-redo))

;; experimenting
(use-package rotate
  :quelpa (rotate :fetcher github :repo "daichirata/emacs-rotate")
  :commands rotate-layout-preserve-sides rotate-window-preserve-sides
  :config
  ;; I'm using golden-mode, so 'main/even' rotations are the same for me
  (setq rotate-functions
        '(rotate:main-horizontal
          rotate:main-vertical
          rotate:tiled))
  (defun rotate-layout-preserve-sides ()
    "Side windows (e.g. treemacs) don't like rotate-layout implementation."
    (interactive)
    (window-toggle-side-windows)
    (rotate-layout)
    (window-toggle-side-windows))
  (defun rotate-window-preserve-sides ()
    "Side windows (e.g. treemacs) don't like rotate-window implementation."
    (interactive)
    (window-toggle-side-windows)
    (rotate-window)
    (window-toggle-side-windows))
  )

(use-package window
  :after evil
  :commands (hydra-windows/body close-and-kill-next-pane close-and-kill-current-pane)
  :bind
  ("C-x 4 1" . close-and-kill-next-pane)
  ("M-o" . other-window)
  ("M-r" . rotate-layout)
  ;; this gets weird behaviour in terminal e.g. termux overriding <left> <right> etc.
  ;; ("M-O" . other-previous-window)
  ("M-m" . push-buffer-to-the-next-window)
  :general ('(motion normal insert) 'override 
            "M-s" 'save-buffer
            "M-d" 'delete-window)
  :init
  (evil-define-key 'motion global-map
    ;; (kbd "<leader>s") 'save-buffer
    ;; (kbd "<leader>k") 'close-and-kill-current-pane
    (kbd "<leader>w") 'hydra-windows/body
    (kbd "<leader>b") 'ivy-switch-buffer
    (kbd "<leader>B") 'ivy-switch-buffer-other-window
    (kbd "<leader><SPC>") 'god-execute-with-current-bindings
    (kbd "z j") 'evil-next-buffer
    (kbd "z k") 'evil-prev-buffer)
  (defun close-and-kill-next-pane ()
    "If there are multiple windows, then close the other pane and kill the buffer in it also."
    (interactive)
    (other-window 1)
    (kill-buffer (current-buffer))
    (if (not (one-window-p))
        (delete-window)))
  (defun close-and-kill-current-pane ()
    "Kill current buffer and close the pane, works differently to 'kill-buffer-and-window' as it check whether there are other windows at all."
    (interactive)
    (kill-buffer (current-buffer))
    (if (not (one-window-p))
        (delete-window)))
  (defun push-buffer-to-the-next-window ()
    "Push the buffer from the current window to the next non-dedicated window"
    (interactive)
    (when (< 1 (length (window-list)))
      (let* ((this (selected-window))
             (other (next-window))
             (this-buffer (window-buffer this)))
        (while (window-dedicated-p other) ;; cycle until window is not dedicated
          (setq other (next-window other)))
        (set-window-buffer other this-buffer)
        ;; this will bury buffer by default, and close window (see set-last-tab-window-quit-restore hook)
        (quit-window) 
        (select-window other))))
  (defun set-last-tab-window-quit-restore ()
    "Sets 'quit-restore' window parameter if this is the last tab so the window is closed.
     When it's last window in the current tab-bar-tab - close that tab."
    (let* ((tab-line-tabs (tab-line-tabs-window-buffers))
           (windows (window-list))
           (this-window (selected-window))
           (this-buffer (window-buffer this-window)))
      (when (= 1 (length tab-line-tabs)) ;; when it's last tab - hide window
        (if (= 1 (length windows)) ;; and (= 1 (length (tab-bar-tabs)))
            ;; when it's last window in the tab-bar-tab - close tab-bar-tab
            ;; see 'window.el:5175 quit-restore-window'
            (set-window-parameter this-window 'quit-restore
                                  `(window tab ,(previous-window) ,this-buffer))
          ;; (run-with-idle-timer 1 nil #'tab-bar--update-tab-bar-lines)
          (set-window-parameter this-window 'quit-restore
                                `(window window ,(previous-window) ,this-buffer))))))
  (defun other-previous-window ()
    (interactive)
    "Simply select previous window"
    (other-window -1))
  :hook
  (quit-window . set-last-tab-window-quit-restore)
  :pretty-hydra
  (hydra-windows
   (:hint nil :forein-keys warn :quit-key "q" :title (with-faicon "windows" "Windows & Buffers" 1 -0.05))
   ("Windows & Frames"
    (("d" delete-window "delete window")
     ("o" delete-other-windows "delete others" :exit t)
     ("|" split-window-horizontally "split right")
     ("_" split-window-vertically "split below")
     ("a" ace-window "ace" :exit t)
     ("w" other-window "other window")
     ("fk" delete-frame "delete frame")
     ("fo" delete-other-frames "delete others")
     ("fn" make-frame-command "make frame")
     ("u" winner-undo)
     ("U" winner-redo))
    "Move & Size"
    (("B" balance-windows "balance")
     ("L" shrink-window-horizontally "narrow")
     ("H" enlarge-window-horizontally "widen")
     ("J" shrink-window "lower")
     ("K" enlarge-window "heighten")
     ("s" window-swap-states "swap")
     ("R" rotate-layout "rotate layout")
     ("m" rotate-window-preserve-sides "rotate window+sides")
     ("l" rotate-layout-preserve-sides "rotate layout+sides"))
    "Buffer"
    (("r" rename-buffer "rename" :exit t)
     ("c" clone-buffer "clone" :exit t)
     ("p" previous-buffer "previous")
     ("n" next-buffer "next")
     ("b" bury-buffer "bury")
     ("k" kill-current-buffer "kill")
     ("K" close-and-kill-current-pane "kill buf+win" :exit t))
    "Zoom & Alpha"
    (("-" zoom-frm-out "zoom out")
     ("+" zoom-frm-in "zoom in")
     ("=" zoom-frm-unzoom "reset")
     ("0" text-scale-adjust "buffer" :exit t)
     ("<" frame-decr-alpha "alpha -")
     (">" frame-incr-alpha "alpha +")
     ))))
#+end_src

** shuckle
testing it
https://gist.github.com/rksm/8c07d9ccc9e15adf752d3dd73dd9a61e
(shackle-mode)
#+begin_src elisp
(defun rk/open-compilation-buffer (&optional buffer-or-name shackle-alist shackle-plist)
  "Helper for selecting window for opening *compilation* buffers."
  ;; find existing compilation window left of the current window or left-most window
  (let ((win (or (cl-loop for win = (if win (window-left win) (get-buffer-window))
                          when (or (not (window-left win))
                                   (string-prefix-p "*compilation" (buffer-name (window-buffer win))))
                          return win)
                 (get-buffer-window))))
    ;; if the window is dedicated to a non-compilation buffer, use the current one instead
    (when (window-dedicated-p win)
      (let ((buf-name (buffer-name (window-buffer win))))
        (unless (string-prefix-p "*compilation" buf-name)
          (setq win (get-buffer-window)))))
    (set-window-buffer win (get-buffer buffer-or-name))
    (set-frame-selected-window (window-frame win) win)))


(use-package shackle
  :ensure
  :diminish
  :config (shackle-mode)
  :custom
  (shackle-rules '(
                   (compilation-mode :custom rk/open-compilation-buffer :select t)
		           ;;("\\*Apropos\\|Help\\|Occur\\|tide-references\\*" :regexp t :same t :select t :inhibit-window-quit t)
		           ("\\*magit" :regexp t :same t :select t)
		           ("\\*shell.*" :regexp t :same t :select t)
		           ("\\*PowerShell.*" :regexp t :same t :select t)
		           ("\\*Cargo.*" :regexp t :other t :select nil)
		           ("*Messages*" :select nil :other t)
		           ("*go-guru-output*" :select t :same t)
		           ("*Proced*" :select t :same t)
		           ("*Buffer List*" :select t :same t)
		           ("\\*Pp Eval" :regexp t :same nil :select t :other t)
		           ("*Messages*" :same nil :other t :select t :inhibit-window-quit t)

		           ;; slime
		           ("*slime-source*" :select nil :same nil :other t)
		           ("*slime-description*" :select nil :other t :inhibit-window-quit t)
		           ("\\*slime-repl" :regexp t :same nil :select nil :other t)
		           ;; ("\\*sldb" :regexp t :other t :inhibit-window-quit t :select t)
		           ("\\*slime-compilation" :regexp t :same nil :select nil :other t)
		           ("*slime-scratch*" :same nil :select t :other t)

		           ;; ert
		           ("*ert*" :select nil :same nil :other t)

		           ;; clojure
		           ("*sesman CIDER browser*" :inhibit-window-quit t :select t :same t)
		           ("\\*cider-repl" :regexp t :same nil :other t)))
  (shackle-default-rule nil))
#+end_src

** ibuffer

#+begin_src emacs-lisp
;; show invisible buffers: C-u g r
(use-package ibuffer
  ;; :disabled t ;; trying bufler
  :ensure
  ;; :custom
  ;; (ibuffer-saved-filter-groups
  ;;  '(("ibuffer-groups"
  ;;     ("help" (or (mode . helpful-mode) (mode . help-mode) (name . "help")))
  ;;     ("non-file" (and (not (mode . dired-mode)) (not visiting-file) (not (name . "config.org"))))
  ;;     ("work" (or (name . "work\\/") (directory . "Documents/work")))
  ;;     ("emacs" (or (directory . "/usr/local/share/emacs") (directory . "\\.config/emacs") (name . "config.org")))
  ;;     ("system" (or (directory . "\\.config") (directory . "configs")))
  ;;     ("org" (or (name . "Org Agenda") (directory . "documents/org")))
  ;;     )))
  ;; (ibuffer-saved-filters
  ;;  '(("help"
  ;;     (or
  ;;      (mode . helpful-mode)
  ;;      (mode . help-mode)
  ;;      (name . "help")))
  ;;    ("programming"
  ;;     (or
  ;;      (derived-mode . prog-mode)
  ;;      (mode . ess-mode)
  ;;      (mode . compilation-mode)))
  ;;    ("text document"
  ;;     (and
  ;;      (derived-mode . text-mode)
  ;;      (not
  ;;       (starred-name))))
  ;;    ("mail"
  ;;     (or
  ;;      (mode . message-mode)
  ;;      (mode . mail-mode)
  ;;      (mode . gnus-group-mode)
  ;;      (mode . gnus-summary-mode)
  ;;      (mode . gnus-article-mode)))))
  :bind ("C-x C-b" . ibuffer))

(use-package all-the-icons-ibuffer :ensure :after ibuffer
  :disabled
  :hook (ibuffer-mode . all-the-icons-ibuffer-mode))

(use-package nerd-icons-ibuffer :ensure :after ibuffer nerd-icons
  :hook (ibuffer-mode . nerd-icons-ibuffer-mode)) ;; much better than all-the-icons-ibuffer

(use-package ibuffer-vc
  :ensure :demand :after ibuffer
  :config
  (add-hook 'ibuffer-hook
            (lambda ()
              (ibuffer-vc-set-filter-groups-by-vc-root)
              (unless (eq ibuffer-sorting-mode 'alphabetic)
                (ibuffer-do-sort-by-alphabetic))))
  (setq ibuffer-formats
        '((mark modified read-only vc-status-mini " "
                (name 23 23 :left :elide)
                " "
                (size 9 -1 :right)
                " "
                (mode 16 16 :left :elide)
                " "
                (vc-status 16 16 :left)
                " "
                vc-relative-file)))
  )
#+end_src

** bufler
#+begin_src emacs-lisp
(use-package bufler
  :disabled t
  :ensure
  :after tab-bar
  ;;:config (bufler-tabs-mode)
  :bind
  ("C-x C-b" . bufler)
  ("C-x b" . bufler-switch-buffer))
#+end_src

** various
#+begin_src emacs-lisp
(defun my/display-buffer-please-no (buf &rest ignore)
  (error "Inhibited buffer: %s" (buffer-name buf)))

(add-to-list 'display-buffer-alist
             '("\\*Quail Completions" . (my/display-buffer-please-no)))
#+end_src

* * *utils
** utils-hydra
#+begin_src emacs-lisp
(with-eval-after-load 'evil
  (evil-define-key 'motion global-map (kbd "<leader>u") 'utils-hydra/body)
  (evil-define-key 'motion global-map (kbd "<leader>Q") 'save-buffers-kill-emacs))
;;(kbd "<leader>qq") 'save-buffers-kill-terminal

(pretty-hydra-define utils-hydra
  (:hint nil :color blue :quit-key "q" :exit t :title (with-fileicon "fancy" "Utils"))
  ("Emacs"
   (("efs" profiler-start "profile")
    ("efc" #'(lambda () (interactive) (profiler-start 'cpu)) "profile cpu")
    ("efm" #'(lambda () (interactive) (profiler-start 'mem)) "profile mem")
    ("efq" profiler-stop "profile stop")
    ("efr" profiler-report "profile report")
    ("eP" list-packages)
    ;; ("sp" prodigy)
    ("ep" list-processes "processes")
    ("xt" counsel-load-theme "theme")
    ("xu" counsel-unicode-char "unicode")
    ("xs" counsel-set-variable "set variable"))
   "User"
   (("ue" elfeed)
    ("um" mu4e)
    ("uM" mu4e-fast-update-mail-and-index "mu4e upd")
    ("uc" calculator)
    ("ut" google-translate-smooth-translate "ggl-trnsl")
    ("up" pass)
    ("ui" password-store-insert "pass insert")
    ("ue" password-store-edit "pass edit")
    ("uh" hledger-run-command "hledger"))
   "System"
   (("sc" counsel-compile "compile")
    ("sj" counsel-file-jump "file jump")
    ("sl" counsel-locate "locate")
    ("sa" counsel-linux-app "linux app")
    ("st" counsel-tramp "tramp")
    ("sz" counsel-fzf "fzf")
    ("sd" proced)
    ("so" ovpn)
    ("o" crux-open-with "open-with"))
   "Files & Buffers"
   (("gG" counsel-git "git")
    ("gg" counsel-rg "rg")
    ("gr" counsel-git-grep "git grep")
    ("gl" counsel-git-log "git log")
    ("go" counsel-org-file "org file")
    ("gd" find-grep-dired "grep dired")
    ("c" crux-kill-buffer-truename "cp buffer name")
    ("b" counsel-bookmark "bookmark")
    ("r" rename-buffer "rename buffer")
    ("R" rename-file-and-buffer "rename file and buffer")
    ("yn" copy-file-name "copy file name")
    ("yp" copy-file-path "copy file path")
    ("d" crux-delete-file-and-buffer "delete file and buffer")
    ("fs" crux-create-scratch-buffer "scratch")
    ("fe" crux-visit-shell-buffer "find eshell buffer")
    ("fE" crux-visit-term-buffer "find term buffer")
    ("i" find-user-init-file "find config.org")
    ("I" byte-recompile-init-file "byte-recompile config")
    ("D" toggle-window-dedicated "toggle dedicated window"))))

;; define binding lookup for init.el
(defun find-user-init-file ()
  "Edit the `user-init-file', in another window."
  (interactive)
  ;;(find-file-other-window (concat user-emacs-directory "config.org"))
  (find-file (file-truename (concat user-emacs-directory "config.org"))))

(defun toggle-window-dedicated ()
  "Control whether or not Emacs is allowed to display another
buffer in current window."
  (interactive)
  (message
   (if (let (window (get-buffer-window (current-buffer)))
         (set-window-dedicated-p window (not (window-dedicated-p window))))
       "%s: Can't touch this!"
     "%s is up for grabs.")
   (current-buffer)))

(defun rename-file-and-buffer ()
  "Rename the current buffer and file it is visiting."
  (interactive)
  (let ((filename (buffer-file-name)))
    (if (not (and filename (file-exists-p filename)))
        (message "Buffer is not visiting a file!")
      (let ((new-name (read-file-name "New name: " filename)))
        (cond
         ((vc-backend filename) (vc-rename-file filename new-name))
         (t
          (rename-file filename new-name t)
          (set-visited-file-name new-name t t)))))))

;; next two taken from spacemacs
(defun get-file-path ()
  "Retrieve the file path of the current buffer.
Returns:
  - A string containing the file path in case of success.
  - `nil' in case the current buffer does not have a directory."
  (when-let* (file-path (buffer-file-name))
    (file-truename file-path)))

(defun copy-file-name ()
  "Copy and show the file name of the current buffer."
  (interactive)
  (if-let* ((file-path (get-file-path))
            (file-name (file-name-nondirectory file-path)))
      (progn
        (kill-new file-name)
        (message "%s" file-name))
    (message "WARNING: Current buffer is not attached to a file!")))

(defun copy-file-path ()
  "Copy and show the file path of the current buffer."
  (interactive)
  (if-let* ((file-path (get-file-path)))
      (progn
        (kill-new file-path)
        (message "%s" file-path))
    (message "WARNING: Current buffer is not attached to a file!")))

;; todo - add dedicated window to modeline
;; (setq global-mode-string
;;       (cond ((consp global-mode-string)
;;              (add-to-list 'global-mode-string (t (:eval my-func))))
;;             ((not global-mode-string)
;;              (list my-string))
;;             ((stringp global-mode-string)
;;              (list global-mode-string my-string))))

#+end_src

** toggle-hydra
#+begin_src emacs-lisp
(with-eval-after-load 'evil
  (evil-define-key 'motion global-map (kbd "<leader>x") 'toggle-hydra/body))

;; silence byte-compiler
(declare-function lsp-mode "lsp")

(pretty-hydra-define+ toggle-hydra
  (:hint nil :color amaranth :quit-key "q" :title (with-faicon "toggle-on" "Toggle" 1 -0.05))
  ("Emacs"
   (("C-s" desktop-save-mode "desktop mode" :toggle t)
    ("M-s" auto-sudoedit-mode "auto-sudoedit-mode" :toggle t)
    ("de" toggle-debug-on-error "debug on error" :toggle debug-on-error)
    ("dq" toggle-debug-on-quit "debug on C-g" :toggle debug-on-quit))
   "Text"
   (("c" company-mode "company" :toggle t)
    ("C" global-company-mode "company (g)" :toggle t)
    ("y" yas-global-mode "yas (g)" :toggle t)
    ("a" abbrev-mode "abbrev" :toggle t)
    ("n" auto-insert-mode "auto-insert" :toggle t)
    ("m" evil-mc-mode "evil-mc" :toggle t)
    ("v" visual-line-mode "visual-line" :toggle t)
    ("+" evil-snipe-mode "evil-snipe" :toggle t)
    ("t" toggle-truncate-lines "trunc-lines" :toggle truncate-lines)
    ("L" global-hl-line-mode "hl-line (g)" :toggle t)
    ("u" global-evil-surround-mode "evil surround (g)" :toggle t))
   "Prog"
   (("e" electric-operator-mode "electric operator" :toggle t)
    ("f" flycheck-mode "flycheck" :toggle t)
    ("F" global-flycheck-mode "flycheck (g)" :toggle t)
    ("w" global-whitespace-mode "whitespace (g)" :toggle t)
    ("n" display-line-numbers-mode "line numbers" :toggle t)
    ("N" global-display-line-numbers-mode "line numbers (g)" :toggle t)
    ("r" rainbow-mode "rainbow" :toggle t)
    ("H" hl-todo-mode "hl-todo" :toggle t)
    ("o" origami-mode "origami" :toggle t)
    ("H" hs-minor-mode "hide-show" :toggle t)
    ("E" editorconfig-mode "editorconfig" :toggle t)
    ("P" smartparens-strict-mode "smartpar strct" :toggle t)
    ("S" show-smartparens-mode "show smartparens" :toggle t)
    ("s" smartparens-mode "smartparens" :toggle t))
   "UI"
   (("i" ivy-rich-mode "ivy-rich" :toggle t)
    ("b" buffer-tab-assign-mode "auto-buf-tab" :toggle t)
    ("h" back-button-mode "back-button" :toggle t)
    ("pw" which-key-posframe-mode "wk-posframe" :toggle t)
    ("ph" hydra-posframe-mode "hydra-posframe" :toggle t)
    ("pi" ivy-posframe-mode "ivy-posframe" :toggle t)
    ("g" good-scroll-mode :toggle t)
    ("G" golden-ratio-mode :toggle t)
    ("T" my/toggle-light-dark "light/dark theme" :toggle my/toggle-dark)
    ("B" page-break-lines-mode "page brks" :toggle t)
    ("D" dimmer-mode "dim others" :toggle t)
    )))
#+end_src

* * *org
** org
#+begin_src emacs-lisp
(use-package org-contrib
  :ensure :demand :after org
  :custom (org-expiry-inactive-timestamps t)
  :config (require 'org-expiry)
  :hook
  ;; adds CREATED property - works after each capture
  ((org-capture-before-finalize . (lambda() (save-excursion (org-back-to-heading) (org-expiry-insert-created))))
   ;; adds CREATED property - works after changing state
   (org-after-todo-state-change . (lambda ()
                                    (when (string= org-state "TODO")
                                      (save-excursion (org-back-to-heading) (org-expiry-insert-created)))))))

(use-package org
  ;;:ensure org-contrib ;; this is how it works - name of the actual package to load
  :ensure
  :pin gnu
  :defines (org-state) ;; to silence byte-compiling on after-state-change hooks (see at the bottom of :config)
  :after evil
  :init
  (evil-define-key 'motion global-map
    (kbd "<leader>o") 'hydra-org/body
    (kbd "<leader>a") 'org-agenda
    (kbd "<leader>i") 'org-capture)
  (evil-define-key 'motion org-mode-map (kbd "<leader>/") 'org-goto)
  (general-def '(normal motion) org-mode-map "M-l" nil "M-h" nil "M-j" nil "M-k" nil)
  (general-def '(insert motion) org-mode-map
    "C-S-h"   'org-shiftleft     "C-S-l"   'org-shiftright
    "C-S-k"   'org-shiftup       "C-S-j"   'org-shiftdown
    "C-M-h" 'org-metaleft      "C-M-l" 'org-metaright
    "C-M-k" 'org-metaup        "C-M-j" 'org-metadown
    "C-M-S-h"   'org-shiftmetaleft "C-M-S-l"   'org-shiftmetaright
    "C-M-S-k"   'org-shiftmetaup   "C-M-S-j"   'org-shiftmetadown
    )
  (defun markdown-to-org-region (start end)
    "Convert markdown in the selected region to org-mode using pandoc."
    (interactive "r")
    (message (format "%s" start))
    (if (use-region-p)
        (shell-command-on-region start end "pandoc -f markdown -t org"
                                 "*md-to-org out*" t "*md-to-org err*" t)
      (message "No region selected. Please select a region first.")))
  :general ([remap org-goto] 'counsel-org-goto)
  :config
  (define-key org-mode-map [(double-mouse-1)] 'org-cycle)
  :bind (:map org-src-mode-map ("C-c C-c" . org-edit-src-exit))
  :commands (org-capture hydra-org/body)
  :custom
  (org-archive-location "~/documents/org/archive/%s_archive::")
  (org-directory "~/documents/org/")
  (org-tags-exclude-from-inheritance (quote ("project" "area")))
  (org-tags-column 0) ;; -70
  (org-auto-align-tags nil)
  (org-export-backends '(ascii html odt latex md))
  ;; more modules - longer load time
  (org-modules
   '(
     ;;ol-bbdb ol-bibtex
     ;;org-crypt
     ;;ol-docview
     ;;ol-eww
     org-id
     ;;ol-info
     ;;org-inlinetask org-mouse org-tempo
     ;;ol-w3m ol-eshell
     ;;org-annotate-file ol-bookmark org-checklist org-choose
     ;;org-learn org-screenshot orgtbl-sqlinsert org-toc
     ))
  ;;(org-format-latex-options (plist-put org-format-latex-options :scale 1.5))
  ;; refile
  (org-outline-path-complete-in-steps nil)          ; Refile in a single go
  (org-refile-use-outline-path 'file)               ; Show full paths for refiling - trick to refile in 0 level
  (org-refile-allow-creating-parent-nodes 'confirm) ; create new parent on the fly
  (org-goto-interface 'outline-path-completion)
  (org-outline-path-complete-in-steps nil)
  ;; id
  (org-id-link-to-org-use-id 'create-if-interactive)  ;; 'use-existing' will not create id on 'org-store-link'
  ;;'create-if-interactive-and-no-custom-id
  (org-link-search-must-match-exact-headline nil) ;; headline search link
  (org-catch-invisible-edits 'show-and-error)
  (org-insert-heading-respect-content t)
  ;; startup
  (org-hide-leading-stars t)
  (org-startup-folded t)
  ;;(org-startup-folded 'fold)
  (org-startup-indented t)
  ;; experiments
  (org-indent-indentation-per-level 4)
  (org-ellipsis "…")
  (bidi-paragraph-direction t)
  (org-hide-emphasis-markers t)
  (org-level-color-stars-only t)
  (org-fontify-todo-headline t)
  (org-fontify-done-headline t)
  (org-fontify-whole-heading-line t)
  (org-fontify-quote-and-verse-blocks t)
  (org-cycle-emulate-tab t) ;; default setting - TAB in org fallbacks to indent
  (org-hidden-keywords '(title startup)) ;; hide #+TITLE keyword in the header
  (org-return-follows-link t) ;; ret follows link (in evil, go to <insert> and then return)
  (org-pretty-entities t) ;; unless org-use-sub-superscripts is nil, this option turns on on every snakecase x_1
  (org-use-sub-superscripts '{})
  (org-priority-default ?C)
  (org-priority-lowest ?D)
  ;; I'm currently considering such mapping for
  ;; Eisenhower matrix to org-priorities:                 +---+---+
  ;; A   Do        +important+urgent                      | A | B |
  ;; B   Decide    +important-urgent                      +---+---+
  ;; C   Delegate  -important+urgent                      | C | D |
  ;; D   Delete    -important-urgent                      +---+---+
  ;; may switch to using tags (important/urgent)
  ;; (org-priority-faces '((?A . (:foreground "red1")) ;; :weight 'bold
  ;;                       (?B . (:foreground "yellow2"))
  ;;                       (?C . (:foreground "green2"))
  ;;                       (?D . (:foreground "RoyalBlue"))))
  ;; light-mode
  (org-priority-faces '((?A . (:foreground "#da0900")) ;; :weight 'bold
                        (?B . (:foreground "#a97900"))
                        (?C . (:foreground "#228833"))
                        (?D . (:foreground "#443399"))))
  (org-log-done t)
  (org-use-property-inheritance nil) ;'("GOAL" "VISION")) ;; we can control inheritance directly in function org-entry-get
  (org-log-into-drawer "LOGBOOK") ;; log into LOGBOOK
  (org-adapt-indentation t)
  ;;(org-checkbox-hierarchical-statistics t)
  (org-hierarchical-todo-statistics nil) ;; same as using :COOKIE_DATA: recursive - will count '%' recursively not only direct children
  (org-checkbox-hierarchical-statistics nil) ;; this will count not only direct children checks
  ;;(org-enforce-todo-checkbox-dependencies t)
  ;; effort & column view
  ;;(org-columns-default-format "%25ITEM %TODO %3PRIORITY %TAGS")
  (org-columns-default-format-for-agenda "%60ITEM(Task) %6Effort(Estim){:}")
  (org-global-properties nil ;; '(("Effort_ALL" . "0 0:05 0:10 0:15 0:25 0:30 0:45 1:00 2:00 3:00 4:00 5:00 6:00 7:00 10:00 15:00 24:00"))
                         )
  (org-attach-dir-relative t)
  (org-attach-preferred-new-method 'dir)
  (org-link-abbrev-alist '(("att" . org-attach-expand))) ;; this allows using links to e.g. images attachments as att:1.png
  (org-archive-default-command 'org-archive-subtree-hierarchical)
  ;; counsel
  (counsel-org-headline-display-tags t)
  (counsel-org-headline-display-todo t)
  (counsel-org-headline-display-comment t)
  (counsel-org-headline-display-priority t)
  (counsel-org-headline-display-statistics t)
  :custom-face
  ;; (org-headline-done ((t (:foreground "DarkOliveGreen1"))))
  ;; (org-headline-todo ((t (:foreground "plum1"))))
  ;; (org-todo ((t (:family  "Fira Code" :foreground "hot pink"))))
  ;; light-mode
  (org-headline-done ((t (:foreground "#556b2f"))))
  (org-headline-todo ((t (:foreground "#7d40ad"))))
  (org-todo ((t (:family  "Fira Code" :foreground "#990532"))))
  (org-done ((t (:family  "Fira Code"))))
  (org-priority ((t (:family  "Input Mono" :width extra-expanded))))
  (org-rainbow-tags--ATTACH ((t (:foreground "goldenrod2"))))
  :config
  (require 'org-archive-subtree-hierarchical)
  (require 'org-attach)
  (require 'org-inlinetask)
  (require 'org-protocol)
  (require 'org-capture-pop-frame) ;; EXPERIMENT
  (with-eval-after-load 'org-indent
    (diminish 'org-indent-mode ""))
  (define-key org-mode-map [(control tab)] nil) ;; unset - C-tab used for tab cycling
  (define-key org-mode-map (kbd "M-h") nil) ;; unset - M-h used for previous-buffer
  ;;(org-indent-mode t) ;; todo - electric-indent-mode
  ;;this one seems to work only with deadlines
  ;; (when (display-graphic-p)
  ;;   (require 'org-notify))
  ;;(org-notify-start)
  (with-eval-after-load 'ox-html
    (add-to-list 'org-html-inline-image-rules '("https" . "lh3.googleusercontent.com"))) ;; google photos links are without extension

  ;;:experimental:
  (font-lock-add-keywords 'org-mode
                          '(("^ *\\([-]\\) "
                             (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•"))))))
  (unless is-android
    (let* ((variable-tuple
            (cond ((x-list-fonts "ETBembo")         '(:font "ETBembo"))
                  ((x-list-fonts "Source Sans Pro") '(:font "Source Sans Pro"))
                  ((x-list-fonts "Lucida Grande")   '(:font "Lucida Grande"))
                  ((x-list-fonts "Verdana")         '(:font "Verdana"))
                  ((x-family-fonts "Sans Serif")    '(:family "Sans Serif"))
                  (nil (warn "Cannot find a Sans Serif Font.  Install Source Sans Pro."))))
           (base-font-color     (face-foreground 'default nil 'default))
           (headline           `(:inherit default :weight bold :foreground ,base-font-color)))

      (custom-theme-set-faces
       'user
       `(org-level-8 ((t (,@headline ,@variable-tuple))))
       `(org-level-7 ((t (,@headline ,@variable-tuple))))
       `(org-level-6 ((t (,@headline ,@variable-tuple))))
       `(org-level-5 ((t (,@headline ,@variable-tuple))))
       `(org-level-4 ((t (,@headline ,@variable-tuple :height 1.05))))
       `(org-level-3 ((t (,@headline ,@variable-tuple :height 1.15))))
       `(org-level-2 ((t (,@headline ,@variable-tuple :height 1.25))))
       `(org-level-1 ((t (,@headline ,@variable-tuple :height 1.5))))
      `(org-document-title ((t (,@headline ,@variable-tuple :height 2.0 :underline nil))))))

     )
  (custom-theme-set-faces
   'user
   '(org-block ((t (:inherit fixed-pitch))))
   '(org-code ((t (:inherit (shadow fixed-pitch)))))
   '(org-document-info ((t (:foreground "dark orange"))))
   '(org-document-info-keyword ((t (:inherit (shadow fixed-pitch)))))
   '(org-indent ((t (:inherit (org-hide fixed-pitch)))))
   '(org-link ((t (:foreground "royal blue" :underline t))))
   '(org-meta-line ((t (:inherit (font-lock-comment-face fixed-pitch)))))
   '(org-property-value ((t (:inherit fixed-pitch))) t)
   '(org-special-keyword ((t (:inherit (font-lock-comment-face fixed-pitch)))))
   '(org-table ((t (:inherit fixed-pitch :foreground "#83a598"))))
   '(org-tag ((t (:inherit (shadow fixed-pitch) :weight bold :height 0.8))))
   '(org-verbatim ((t (:inherit (shadow fixed-pitch))))))


  
  (add-hook 'org-mode-hook 'variable-pitch-mode)
  ;;(add-hook 'org-mode-hook 'mixed-pitch-mode)
  ;;(setq-default line-spacing 1)
  (setq-default line-spacing nil)




  :pretty-hydra
  (hydra-org
   (:hint nil :color teal :quit-key "q" :title (with-fileicon "org" "Org" 1 -0.05))
   ("Action"
    (("b" org2blog-user-interface "org2blog")
     ("c" org-capture "capture")
     ("S" org-insert-structure-template "structure template")
     ("A" org-archive-done-in-file "archive done in file")
     ("E" org-encrypt-entry "encrypt")
     ("D" org-decrypt-entry "decrypt")
     ("d" org-cut-subtree "cut-subtree")
     ("p" org-paste-subtree "paste-subtree")
     ("r" org-refile "refile"))
    "Search & View"
    (("a" org-agenda "agenda")
     ("n" org-toggle-narrow-to-subtree "narrow")
     ("f" org-tree-to-indirect-buffer "tree to indirect")
     ("j" counsel-org-goto-all "goto")
     ;; ("s" my/org-ql-goals "goals")
     ("I" org-info-find-node "org info find"))
    "Link"
    (("s" org-store-link "store-link")
     ("o" org-open-at-point-global "open-link")
     ("t" org-transclusion-make-from-link "transclude")
     ("T" org-transclusion-mode "transclusion" :toggle t)
     ("l" counsel-org-link "counsel link")
     ("L" org-insert-link-global "link global")
     ("i" org-id-copy "copy id"))))
  :init
  ;; (defun my/org-ql-goals ()
  ;;   (interactive)
  ;;   (org-ql-search (org-agenda-files) '(and (todo) (not (todo "GOAL")) (not (todo "VISION")))
  ;;     :super-groups '((:auto-map
  ;;                      (lambda (item)
  ;;                        (-when-let* ((goal-link (org-entry-get (org-super-agenda--get-marker item) "GOAL")))
  ;;                          (message goal-link)
  ;;                          (org-link-open-from-string goal-link)
  ;;                          (org-get-heading 'notags 'notodo)))))))
  ;;;; archive all DONEs in file ;;;;
  ;; in-progress, but not needed actually - do the same - C-c a T DONE * B $
  (defun org-archive-done-in-file ()
    (interactive)
    (org-map-entries 'org-archive-subtree "/DONE" 'file)))
#+end_src

** org-babel
#+begin_src emacs-lisp
;; babel header info - https://org-babel.readthedocs.io/en/latest/header-args/#results
(use-package ob ;org-babel
  :after org
  :commands (my/tangle-async)
  :config
  (require 'async)
  (defun my/tangle-async ()
    "Tangle asynchronously current file."
    (interactive)
    (let ((file (buffer-file-name)))
      (async-start
       `(lambda ()
          (require 'org)
          (org-babel-tangle-file ,file))
       `(lambda (result)
          (message (format "tangle-async finished for: %s" result))
          (mapcar (lambda (out-file)
                    ;; make it a flag input arg?
                    (when (string-match-p ".el$" out-file)
                      ;;(message out-file)
                      ;; byte/native-compilation doesn't really speed up init
                      ;;(byte-recompile-file out-file)
                      ;; native compile
                      ;; async native-compile has some problems, only synchronous works with native-compile
                      ;;(native-compile-async out-file) ;nil t nil) ;; load file after async finish
                      ))
                  result)
          ;;(message (format "byte&native recompile finished"))
          ))))
  (diminish 'org-src-mode)
  :custom
  ((org-confirm-babel-evaluate (lambda (lang body) (not (member lang '("plantuml" "emacs-lisp" "sql" "sh" "sqlite" "sql-mode")))))
   (org-babel-load-languages
    '((emacs-lisp . t) ;(gnuplot . t) ;(python . t)
      (python . t)
      ;;(jupyter . t)
      (plantuml . t)
      (shell . t) ;(ledger . t) ;(sqlite . t)
      (sql . t)))
   (org-plantuml-jar-path (expand-file-name "/usr/share/java/plantuml/plantuml.jar"))
   (add-to-list 'org-src-lang-modes '("plantuml" . plantuml))
   (org-src-preserve-indentation t) ;; without this it gets crazy when editing src inline
   (org-src-fontify-natively t)
   (org-src-window-setup 'current-window) ; 'plain 'split-window-right ;reorganize-frame;'current-window
   (org-src-tab-acts-natively t)
   (org-edit-src-persistent-message nil)
   )
  :hook
  ;; auto redisplay image after C-c C-c otherwise need to manually C-cxv
  (org-babel-after-execute . org-redisplay-inline-images)
  ;; automatically open src edit when in the src block
  (org-mode . (lambda()
                (make-local-variable 'evil-insert-state-entry-hook)
                (add-hook 'evil-insert-state-entry-hook #'org-edit-src-code))))

(use-package ob-async
  :ensure :after org)

(use-package ob-latex
  :config

  ;; I'm new to latext - this was taken from https://sqrtminusone.xyz/posts/2021-05-01-org-python/#basic-tables
  
  (setq org-latex-compiler "xelatex") ;; Probably not necessary
  (setq org-latex-pdf-process '("latexmk -outdir=%o %f")) ;; Use latexmk
  (setq org-latex-listings 'minted)   ;; Use minted to highlight source code
  (setq org-latex-minted-options      ;; Some minted options I like
        '(("breaklines" "true")
          ("tabsize" "4")
          ("autogobble")
          ("linenos")
          ("numbersep" "0.5cm")
          ("xleftmargin" "1cm")
          ("frame" "single")))
  ;; Use extarticle without the default packages
  (add-to-list 'org-latex-classes
               '("org-plain-extarticle"
                 "\\documentclass{extarticle}
[NO-DEFAULT-PACKAGES]
[PACKAGES]
[EXTRA]"
                 ("\\section{%s}" . "\\section*{%s}")
                 ("\\subsection{%s}" . "\\subsection*{%s}")
                 ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
                 ("\\paragraph{%s}" . "\\paragraph*{%s}")
                 ("\\subparagraph{%s}" . "\\subparagraph*{%s}"))))
#+end_src

** capture templates

#+begin_src emacs-lisp
(defun my/switch-to-org-tab() (tab-bar-select-tab-by-name "org"))
(setq org-capture-templates
      '(
        ("c" "calfw2org" entry (file "inbox.org")  "* %? %(cfw:org-capture-day)")
        ("i" "[inbox]" entry (file "inbox.org" ) "* %i%?")
        ("o" "Link capture" entry (file "inbox.org") ;; file+olp "links.org" "inbox"
         ;; used by org-protocol capture
         ;; %:link          The URL
         ;; %:description   The webpage title
         ;; %:annotation    Equivalent to [[%:link][%:description]]
         ;; %i              The selected text
         "* #\" %a\n#+BEGIN_QUOTE\n%i\n#+END_QUOTE\n%?" ;; %a %U
         ;;:immediate-finish t
         ;;:jump-to-captured t
         ;;:hook my/switch-to-org-tab
         ;; todo - fix buffers with auto-buf-tab mode
         ;;:tree-type week
         )
        ("L" "Protocol Link" entry (file "inbox.org") ;;:EXPERIMENT:
         "* # %a%?") ;; %a %U
        ("w" "Weekly" item (file+olp+datetree "goals.org") "* %?" :tree-type week) ;; :EXPERIMENT:
        ("g" "Goal" entry (file "goals.org") "* GOAL *%^{Goal title}* \t:%^G:goal:\n\
:PROPERTIES:\n:CREATED: %U\n:END:\n\
%^{Goal description}")
        ("p" "Project" entry (file "inbox.org") "* PROJECT *%^{Project title}* [%] :%^G:project:\n\
:PROPERTIES:\n:CREATED: %U\n:END:\n\
GOAL: %^{Project goal}\n\
- [ ] %^{item1}")
        ("h" "Habit" entry (file+headline "personal.org" "*habits*") "* %?\n\
SCHEDULED: <%<%Y-%m-%d %a .+1d>>\n\
:PROPERTIES:\n\
:CREATED: %U\n\
:STYLE: habit\n\
:REPEAT_TO_STATE: \n\
:LOGGING: DONE(!)\n\
:ARCHIVE: archive/%s_archive::* Habits\n\
:END:\n")
        ("a" "Appointment" entry (file  "gcal/personal.org") "* %?\n\n%^T")
        ("j" "Journal" entry (file+olp+datetree "journal.org")
         "* %<%H:%M> %?\n %i From: %a" :empty-lines 1)
        ("e" "Word [english]" entry (file "english.org") "* %i%?")
        ("O" "Org idea" entry (file+olp "org.org" "ideas" "org ideas") "*** TODO %i%?")
        ("b" "Buylist" entry (file+olp "personal.org" "*buylist*") "** TODO %i%?")
        ("m" "Meal" entry (file+olp "food.org" "_MEAL_")
         "** %t meal\n\t- breakfast: %^{Breakfast}\n\t- lunch: %^{Lunch}\n\t- snack: %^{Snack}\n\t- dinner: %^{Dinner}")
        ("t" "Personal task" entry (file+olp "personal.org" "_TASKS_") "** TODO %i%?\n   SCHEDULED: <%<%Y-%m-%d %a>>")
        ("I" "Idea")
        ("Ib" "talk/blog" entry (file+olp "ideas.org" "*talk/blog*") "** TODO %i%?")
        ("E" "Emacs todo" entry (file+headline "emacs.org" "ideas / todo") "* TODO %i%?")))

;; description of capture
;;(setq org-capture-templates '((
;;     "t"                ; key
;;     "Todo"             ; description
;;     entry              ; type
;;     (file+headline "C:/.../org/notes.org" "tasks")       ; target
;;     "* TODO [#B] %^{Todo} %(org-set-tags) \n:PROPERTIES:\n:Created: %U\n:END:\n\n%?"  ; template
;;     :prepend t        ; properties
;;     :empty-lines 1    ; properties
;;     :created t        ; properties
;;     )))


(use-package org-capture-pop-frame
  ;;:disabled
  ;; *ERROR*: No applicable method: frame-creation-function,
  ;; ((client . #<process server <1>>) (right-fringe . 16) (left-fringe . 16)
  ;; (tab-bar-lines . 0) (window-system . x) (name . "capture-pop-frame") (width . 100)
  ;; (height . 30) (alpha 95 . 95) (tool-bar-lines . 0) (menu-bar-lines . 0)) 
  :ensure
  :custom ocpf-frame-parameters
  '((name . "capture-pop-frame")
    ;;(window-system . pgtk)
    (width . 100)
    (height . 30)
    (alpha . (95 . 95))
    (tool-bar-lines . 0)
    (menu-bar-lines . 0))
  )
#+end_src

** keywords & tags

#+begin_src emacs-lisp
(setq org-todo-keywords
      '(
        (sequence "." "[ ](t)" "[?]" "[~]" "[w]" "~:" "|" "[v](v)" "[d]" "[x]" ".=" "-" "--" ":" "@" "*") ;; :EXPERIMENT: reminder,subtask:todo/done,container(e.g. notes),area, [,] moved to next?, --:divider
        (sequence "TODO(t)" "DRAFT(l)" "DOING(i)" "TRACK(T)" "PROCESS(P)" "WAITING(w!)" "DELEGATED(e!)" "ON-HOLD(h!)" "|") ;; h@/!
        (sequence "IDEA(i)" "MAYBE(m)" "SOMEDAY(s)" ".." "|") ;; :EXPERIMENT: ..=someday
        (sequence "!PROJECT(p)" "PROJECT?" "PROJECT" "~PROJECT" "PROJECT~" "PROJECT," "PROJECT;" "|" "PROJECT=" "PROJECT." "PROJECT-")
        (sequence "VISION(v)" "GOAL(g)" "FOCUS(f)" "MODE(o)" "|" "MODE.")
        (type "|" "WEAKNESS(n)" "TECHNIQUE(q)" "HABIT(j)" "CHEATSHEET(a)" "RESOLUTION(r)")
        (type "BOOK" "MOVIE" "SHOW" "|" "WATCHED")
        (type "|" "~INFO" "INFO(I)")
        (type "BUY?" "BUY~" "BUY" "BUY.." "SELL" "SELL?" "SELL~" "|" "BOUGHT" "SOLD")
        (type "|" "~SKILL(k)" "SKILL~" "RULE" "SKILL(K)")
        (type "~LEARN" "LEARN" "LEARN~" "|" "LEARNED")
        (type "|" "~POST" "POST~" "POST" "~MESSAGE" "~COMMENTARY" "COMMENTARY" "MESSAGE" "POST=")
        (type "|" "~!+" "!+" "+" "~+" "+~" "+?" "FIX" "FIX~" "TRY" "TRY~" "EXPLORE~" "EXPLORE" "USE" "USE~" "!BUILD" "~BUILD" "BUILD" "+." "FIXED" "TRIED" "USED" "BUILT")
        (type "|" "#~" "#\"~" "!#" "#" "# paper" "# course" "# lib" "# story" "# video" "# tutorial" "#=" "!#=" "#\"") ;; link/annotation/snippet/bookmark, maybe use 🔗
        (type "|" "\"~" "~" "?" "?~" "?=~" "~=" "=\"~" "~-=" "*~" "=~" "=\"" "\"" "?=" "=" "-=") ;; topic/category question/resolution :EXPERIMENT:
        (type "|" "~!" "!" "!?" "!org") ;; idea :EXPERIMENT:
        (type "|" "~DESIGN" "~RESEARCH" "DESIGN~" "RESEARCH~" "TRACE~" "TRACE" "DESIGN" "RESEARCH") ;; RESEARCH? :EXPERIMENT:
        (type "|" "~SYSTEM" "~SPEC(E)" "SPEC?" "ELEMENT?" "~ELEMENT?" "~!ELEMENT" "~ELEMENT" "~SYMBOL" "~-TRAIT" "~-ATTRIBUTE" "SYSTEM" "SPEC(E)" "ELEMENT(L)" "SYMBOL" "TRAIT" "-TRAIT" "-ATTRIBUTE") ;; meta
        (type "|" "~SCRIPT" "~ROUTINE" "~ACTIVITY" "~ACTIVITY?" "ROUTINE(R)" "ACTIVITY(A)" "SCRIPT" "INVENTORY(V)" "LOG" "THOUGHT" "AGENDA" "PRINCIPLE") ;; org, PLAN?
        (sequence "|" "DONE(d!)" "CLOSED(c!)" "CANCELLED(C!)" "DUPLICATE(D)" "SKIPPED(S/!)")
        )
      )


;; Setting Colours (faces) for todo states to give clearer view of work
;; lookup by M-x list-colors-display
(setq org-todo-keyword-faces
      '(
        ("PROJECT" . "maroon2")
        ("GOAL" . "SeaGreen4")
        ("VISION" . "DeepSkyBlue")
        ("FOCUS" . "orange")
        ("IDEA" . "orange")
        ("WEAKNESS" . "violet")
        ("RESOLUTION" . "turquoise")
        ("~" . "magenta")
        ("?~" . "magenta")
        ("\"~" . "magenta")
        ;; ("*" . "green2") ;; turquoise
        ("*" . "green3") ;; turquoise
        ("--" . "dark grey") ;; turquoise
        ("RESEARCH" . "orange3")
        ("TRACE" . "orange")
        ("TECHNIQUE" . "aquamarine")
        ("BOOK" . "darkorange")
        ("CHEATSHEET" . "turquoise")
        ("SKILL" . "PaleGreen")
        ("HABIT" "chocolate4")
        ("MODE" . "peru")
        ("TODO" . "OrangeRed")
        ("." . "gold")
        ("DRAFT" . "orange red")
        ("SOMEDAY" . "IndianRed2")
        (".." . "IndianRed2")
        ("MAYBE" . "IndianRed2")
        ("[?]" . "IndianRed2")
        ("BUY?" . "IndianRed2")
        ("DOING" . "dark goldenrod")
        ("[~]" . "dark goldenrod")
        ("BUY~" . "dark goldenrod")
        ("TRACK" . "violet")
        ("PROCESS" . "goldenrod")
        ("WAITING" . "blue violet")
        ("[w]" . "blue violet")
        ("DELEGATED" . "dark olive green")
        ("ON-HOLD" . "dark orange")
        ("PROJECT;" . "dark orange")
        ("DONE" . "forest green")
        ("[v]" . "forest green")
        ("CLOSED" . "cyan4")
        ("[x]" . "cyan4")
        ("DUPLICATE" . "cyan4")
        ("CANCELLED" . "cyan4")
        ("SKIPPED" . "cyan4")
        )
      )
;; TODO=#fe450e")

(setq org-tag-alist
      '(("@org" . ?o)
        ("@emacs" . ?e)
        ("@linux" . ?l)
        ("@tools" . ?t)
        ("@work" . ?w)
        ("goal" . ?g)
        ("family" . ?f)
        ("personal" . ?p)
        ("project" . ?P)
        ("area" . ?A)
        ("health" . ?h)
        ("buy" . ?b)
        ("sell" . ?s)
        ("income" . ?I)
        ("expense" . ?E)
        ("deep" . ?d)))
#+end_src

#+RESULTS:
: ((@org . 111) (@emacs . 101) (@linux . 108) (@tools . 116) (@work . 119) (goal . 103) (family . 102) (personal . 112) (project . 80) (area . 65) (health . 104) (buy . 98) (sell . 115) (income . 73) (expense . 69) (deep . 100))

** evil-org

#+begin_src emacs-lisp
(use-package evil-org
  :ensure :diminish
  :after evil org
  :hook (org-mode . evil-org-mode)
  :custom (evil-org-key-theme '(navigation insert textobjects calendar)) ; no  'additional' - conflict with windmove
  )

(use-package evil-org-agenda
  :demand :after evil-org org-agenda
  :config
  (evil-org-agenda-set-keys)
  (general-def 'motion org-agenda-mode-map "SPC" (general-simulate-key "<leader>"))
  (evil-define-key 'motion org-agenda-mode-map
    (kbd "M-k") nil (kbd "M-j") nil  ;; free up for windmove
    "ZK" 'org-habit-toggle-display-in-agenda
    "ZD" 'org-agenda-toggle-deadlines
    "T" 'org-agenda-todo-yesterday))
#+end_src

** org-agenda

#+begin_src emacs-lisp
(use-package org-agenda
  ;; :after evil general
  :custom
  (org-id-search-archives nil)
  (org-modules '(org-habit org-id))
  (org-agenda-tags-column -50)
  (org-extend-today-until 2) ;; the day ends at 2am
  (org-habit-graph-column 35;; (if is-android 35 58)
                          )
  (org-habit-show-all-today nil)
  (org-habit-preceding-days 17)
  (org-habit-following-days 5)
  (org-agenda-prefix-format '((agenda . " %i %-16:c%?-12t% s") ;(agenda . " %i %-23b %-16:c%?-12t% s")
                              (todo . " %i ")
                              (tags . " %i ")
                              (search . " %i %-16:c")))
  (org-stuck-projects '("+project" ("TODO" "DOING") nil "")) ;default ;'("+LEVEL=2/-DONE" ("TODO" "NEXT" "NEXTACTION") nil ""))
  (org-deadline-warning-days 7)
  (org-agenda-breadcrumbs-separator " ❱ ")
  (org-agenda-log-mode-items '(state) ;; '(closed state)
                             )
  ;;(setq org-ellipsis "…")
  (org-agenda-skip-scheduled-delay-if-deadline t)
  (org-agenda-skip-scheduled-if-deadline-is-shown t)
  (org-agenda-skip-deadline-prewarning-if-scheduled t)
  (org-agenda-block-separator (string-to-char " "))
  (org-agenda-compact-blocks t) ;; makes everything much more compact, makes above option redundant as there are no separators
  ;; doesn't really work for todo/tags
  ;; (org-agenda-sorting-strategy
  ;;  '((agenda habit-down time-up priority-down category-keep)
  ;;   (todo priority-down category-keep)
  ;;   (tags priority-down category-keep)
  ;;   (search category-keep))
  ;;  )
  (org-agenda-entry-text-maxlines 20)
  (org-agenda-entry-text-leaders "          ")
  :config
  (require 'org)
  (require 'org-habit)
  (org-id-update-id-locations nil t)
  ;;(evil-set-initial-state 'org-agenda-mode 'motion)
  (require 'org-clock-budget)
  (require 'bookmark)
  (bookmark-maybe-load-default-file) ;; this is for agenda hook below
  (add-to-list 'display-buffer-alist '("*Org Agenda*"
                                       (display-buffer-reuse-window display-buffer-in-direction
                                                                    ;; side-window is problematic e.g. when trying to delete-other-windows or using org-agenda-todo
                                                                    ;;display-buffer-in-side-window
                                                                    )
                                       (direction . right)
                                       (side . right)
                                       (slot . -1)
                                       (window-width . 0.5)
                                       (reusable-frames . nil)))
  ;; i like it
  (general-def '(normal insert motion) org-agenda-mode-map "<backtab>" 'org-agenda-entry-text-mode)
  (general-def '(normal insert motion) org-agenda-mode-map "<tab>" 'origami-toggle-node)
  (require 'origami) ;; I only use it for org-[super]-agenda folding, other stuff (evil-fold-toggle) doesn't work
  (general-def '(normal insert motion) org-agenda-keymap "<tab>" 'origami-toggle-node)
  (general-def '(normal insert motion) org-agenda-mode-map "M-m" 'push-buffer-to-the-next-window)
  :hook
  ;; (org-agenda-mode . org-agenda-entry-text-mode)
  (org-agenda-mode . origami-mode)
  (org-agenda-mode . (lambda () ;; to make agenda buffer part of org directory project
                       (setq default-directory org-directory)))
  
  )

#+end_src

** org-agenda custom commands

#+begin_src emacs-lisp
(defun agenda-tags-todo-with-goals (title todo-keyword query)
  `(tags-todo ,query
              ((org-agenda-overriding-header ,title)
               (org-agenda-todo-keyword-format ,todo-keyword)
               (org-agenda-remove-tags t)
               (org-agenda-prefix-format (if is-android
                                             "%?-12t% s"
                                           ;; " %-3i %12c %-17(concat \"❱ \" (my/org-get-parent-goal)) "
                                           " %i %t %s "
                                           ))
               (org-agenda-todo-keyword-format "%9s"))))

(defun agenda-schedule (&optional priority)
  (let* ((skip-func (if priority `(and
                                   (not (or
                                         (not (equal "habit" (org-entry-get nil "STYLE"))) ; skip not-<priority> habits, leave scheduled/deadlines
                                         (equal ,priority (org-entry-get nil "PRIORITY"))))
                                   (point-at-eol)) nil))
         (log-mode (if (not (string= priority "A")) 't 'nil)))
    `(agenda "" ((org-agenda-span 30)
                 (org-agenda-skip-function ',skip-func)
                 (org-agenda-show-log ,log-mode)
                 (org-agenda-todo-keyword-format " 🔨")
                 ;; (org-agenda-skip-scheduled-if-done t)
                 ;; (org-agenda-skip-timestamp-if-done t)
                 ;; (org-agenda-skip-deadline-if-done t)
                 (org-agenda-remove-tags t)
                 ;; (org-agenda-start-day "+0d")
                 ;; (org-agenda-repeating-timestamp-show-all nil)
                 (org-agenda-current-time-string "⮜┈┈┈┈┈┈┈ now")
                 (org-agenda-scheduled-leaders '("⏰" "⏰.%2dx: "))
                 (org-agenda-deadline-leaders '("☠" "In %3d d.: " "%2d d. ago: "))
                 (org-agenda-time-grid (quote ((today require-timed remove-match) (0900 2100) "      " "┈┈┈┈┈┈┈┈┈┈┈┈┈")))
                 (org-agenda-overriding-header "⚡ Schedule:")
                 (org-agenda-prefix-format (if is-android
                                               " %?-12t% s"
                                             ;; " %-3i %12c %-17(concat \"❱ \" (my/org-get-parent-goal)) %?-12t% s"
                                             " %i %t %s "
                                             ))
                 ))))

;; custom agendas ;;
(with-eval-after-load 'org-agenda
  (setq org-agenda-custom-commands
        `(("c" . "Custom Agendas")
          ;; example
          ;; ("k" ;; key
          ;;  "desc" ;; desc
          ;;  tags ;; type
          ;;  "-TODO=\"DONE\"" ;; match
          ;;  nil ;; settings
          ;;  nil ;; no files
          ;;  )
          ;; ("cA" "Appointments" agenda* nil nil)
          ;; ("cs" "Stuck Projects" ((stuck "")) nil nil)
          ;; ("cu" "Unscheduled" ((tags-todo "-project-book/!-GOAL-MODE-FOCUS-VISION-SOMEDAY-MAYBE-DRAFT-IDEA-TOREAD-READING"
          ;;                                 ((org-agenda-overriding-header "\nUnscheduled TODO")
          ;;                                  (org-agenda-skip-function '(org-agenda-skip-entry-if 'timestamp)))))
          ;;  nil nil)
          ;; ("cI" "All A-B Todo" ((tags-todo "-project+PRIORITY={A\\|B}/!-GOAL-VISION-MODE-FOCUS-SOMEDAY-MAYBE-DRAFT-IDEA-TOREAD-READING"))
          ;;  ((org-agenda-overriding-header "All A-B Todo")) nil)
          ;; ("ci" "All In Progress" ((todo "DOING|PROCESS|TRACK")) ((org-agenda-max-entries 25)) nil)
          ;; ("c@" "Areas" ((todo "+@")) nil nil)
          ;; ("ch" "Habits" ((tags "STYLE=\"habit\""))
          ;;  ((org-agenda-overriding-header "Habits")
          ;;   (org-agenda-sorting-stragety '(todo-state-down effort-up category-keep))) nil)
          ("cz" "All TODOs groups by category" alltodo "" ((org-super-agenda-groups '((:auto-category t)))))
          ("cx"
           "All TODOs priority A|B groups by category"
           tags-todo "+PRIORITY={A\\|B}" ((org-super-agenda-groups '((:auto-category t)))))
          ("cX" "All TODOs priority A groups by category" tags-todo "+PRIORITY=\"A\"" ((org-super-agenda-groups '((:auto-category t)))))
          ("cm" "month" agenda "" ((org-agenda-span 'month)))
          ;; ("ca" "Action"
          ;;  (,(agenda-tags-todo-with-goals "⚡ Goals:" " 🟍" "+current+goal")
          ;;   ,(agenda-tags-todo-with-goals "⚡ Doing:" " 🔨" "+TODO={DOING\\|DELEGATED}")
          ;;   ,(agenda-tags-todo-with-goals "⚡ Next:" " ↷" "-project+PRIORITY={A\\|B}+TODO={TODO\\|WAITING}") ;;ON-HOLD\\|
          ;;   ;; ,(agenda-tags-todo-with-goals "⚡ Projects:" " 🔨" "/!PROJECT") ;; for '!' see https://orgmode.org/manual/Matching-tags-and-properties.html
          ;;   ,(agenda-tags-todo-with-goals "⚡ Process:" " 🔨" "+TODO={PROCESS}")
          ;;   ,(agenda-tags-todo-with-goals "⚡ Mode:" " 🔨" "+TODO={MODE}")
          ;;   ,(agenda-tags-todo-with-goals "⚡ Track:" " 🔨" "+TODO={TRACK}")
          ;;   ,(agenda-tags-todo-with-goals "⚡ Ideas:" " 🤔" "+PRIORITY={A\\|B}/!IDEA")
          ;;   ,(agenda-schedule ()))
          ;;  ((ps-number-of-columns 2)
          ;;   (ps-landscape-mode t)
          ;;   (org-agenda-prefix-format " %-3i %12c %?-12t% s")
          ;;   )
          ;;  ("agenda.html"))
          ;; ("c#" "Action #A"
          ;;  (,(agenda-tags-todo-with-goals "⚡ Doing[A]:" " 🔨" "+TODO={DOING\\|PROCESS\\|TRACK\\|WAITING\\|DELEGATED}+PRIORITY={A}")
          ;;   ,(agenda-tags-todo-with-goals "⚡ Next[A]:" " ↷" "-project+PRIORITY={A}+TODO={TODO\\|WAITING}") ;;ON-HOLD\\|
          ;;   ,(agenda-tags-todo-with-goals "⚡ Projects[A]:" " 🔨" "+PRIORITY={A}/!PROJECT")
          ;;   ;; ,(agenda-in-progress "A")
          ;;   ;;,(agenda-next "A")
          ;;   ,(agenda-schedule "A")))
          ("cR" "Week review" agenda ""
           ((org-agenda-span 'week)
            (org-agenda-start-on-weekday 1)
            (org-habit-show-all-today t)
            (org-agenda-overriding-header "Week in Review")
            (org-agenda-show-all-dates t)
            (org-agenda-start-with-log-mode t)
            (org-agenda-log-mode-items '(closed state))
            (org-agenda-start-with-clockreport-mode t)
            (org-agenda-archives-mode t)
            (org-agenda-hide-tags-regexp (concat org-agenda-hide-tags-regexp "\\|ARCHIVE"))))
          ("cr" "All Review"
           ((tags "+blocking/!" ((org-agenda-overriding-header "Blocking others")))
            (tags-todo "+delegated/!+DELEGATED" ((org-agenda-overriding-header "Delegated")))
            (todo "WAITING" ((org-agenda-overriding-header "Waiting for")))
            ;;(tags-todo "+current+goal/!-MODE" ((org-agenda-overriding-header "⚡ Current goals:")))
            ;;(tags-todo "+current/!+MODE" ((org-agenda-overriding-header "⚡ Current mode:")))
            (todo "DOING" ((org-agenda-overriding-header "In progress")))
            (tags-todo "-project+PRIORITY={A\\|B}+TODO={ON-HOLD\\|TODO\\|WAITING}" ((org-agenda-overriding-header "Most important to do")))
            (tags-todo "+project+PRIORITY={A\\|B}" ((org-agenda-overriding-header "A-B Projects")))
            (tags-todo "+project+PRIORITY={C\\|D}" ((org-agenda-overriding-header "Other Projects")))
            (todo "SOMEDAY|MAYBE" ((org-agenda-overriding-header "Someday/Maybe")))
            (tags-todo "-project+PRIORITY={C\\|D}+TODO={ON-HOLD\\|TODO\\|WAITING}"
                       ((org-agenda-overriding-header "Other to do [Scheduled]")
                        (org-agenda-skip-function '(org-agenda-skip-entry-if 'nottimestamp))))
            (tags-todo "-project+PRIORITY={C\\|D}+TODO={ON-HOLD\\|TODO\\|WAITING}+CREATED>\"<-4m>\""
                       ((org-agenda-overriding-header "Other to do [Unscheduled]")
                        (org-agenda-skip-function '(org-agenda-skip-entry-if 'timestamp))))
            (tags-todo "-project+PRIORITY={C\\|D}+TODO={ON-HOLD\\|TODO\\|WAITING}-CREATED>\"<-4m>\""
                       ((org-agenda-overriding-header "Other to do [Unscheduled, Old]")
                        (org-agenda-skip-function '(org-agenda-skip-entry-if 'timestamp))))
            (tags "STYLE=\"habit\"" ((org-agenda-overriding-header "Habits") (org-agenda-sorting-stragety '(todo-state-down effort-up category-keep))) nil)
            (tags "+tech+priorities+current" ((org-agenda-overriding-header "⚡ Current tech priorities:")) ((concat org-directory "consume.org")))
            (tags-todo "+reading" ((org-agenda-overriding-header "⚡ Books:")) ((concat org-directory "consume.org")))
            ))
          ))
  )

;; agenda icons
(setq org-agenda-category-icon-alist
      `(
        
        ;; colors - /home/twist/.config/emacs/elpa/all-the-icons-20240108.559/all-the-icons-faces.el
        ("personal" ,(list (all-the-icons-faicon "check-circle" :face 'all-the-icons-yellow)))
        ("personal" ,(list (all-the-icons-faicon "home")) nil nil :ascent center)
        ("work" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("explore" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("buylist" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("configuration" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("goals" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("home" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("inbox" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("knowledge" ,(list (all-the-icons-faicon "black-tie")) nil nil :ascent center)
        ("content" ,(list (all-the-icons-faicon "video-camera")) nil nil :ascent center)
        ("relationships" ,(list (all-the-icons-faicon "video-camera")) nil nil :ascent center)
        ("study" ,(list (all-the-icons-faicon "video-camera")) nil nil :ascent center)
        ("tools" ,(list (all-the-icons-faicon "video-camera")) nil nil :ascent center)
        ("blog" ,(list (all-the-icons-faicon "book")) nil nil :ascent center)
        ("employment" ,(list (all-the-icons-faicon "male")) nil nil :ascent center)
        ("finance" ,(list (all-the-icons-faicon "money")) nil nil :ascent center)
        ("bigtrip" ,(list (all-the-icons-faicon "tripadvisor")) nil nil :ascent center)
        ("emacs" ,(list (all-the-icons-faicon "linux")) nil nil :ascent center)
        ("software" ,(list (all-the-icons-faicon "code")) nil nil :ascent center)
        ("holiday" ,(list (all-the-icons-faicon "bicycle")) nil nil :ascent center)
        ("health" ,(list (all-the-icons-faicon "medkit")) nil nil :ascent center)
        ("medical" ,(list (all-the-icons-faicon "medkit")) nil nil :ascent center)
        ("mental" ,(list (all-the-icons-faicon "medkit")) nil nil :ascent center)
        ("look" ,(list (all-the-icons-faicon "medkit")) nil nil :ascent center)
        ("cosmetical" ,(list (all-the-icons-faicon "medkit")) nil nil :ascent center)
        ("nutrition" ,(list (all-the-icons-faicon "medkit")) nil nil :ascent center)
        ("physical" ,(list (all-the-icons-faicon "medkit")) nil nil :ascent center)
        ("org" ,(list (all-the-icons-faicon "hourglass") (all-the-icons-icon-for-mode 'org-mode)) nil nil :ascent center)
        ))
;; (setq org-agenda-category-icon-alist nil)

#+end_src

** org-agenda colorize clocks

#+begin_src emacs-lisp :tangle no
(defun org-agenda-log-mode-colorize-block ()
  "Set different line spacing based on clock time duration."
  (save-excursion
    (let* ((colors (cl-case (alist-get 'background-mode (frame-parameters))
                     ((quote light)
                      (list "#F6B1C3" "#FFFF9D" "#BEEB9F" "#ADD5F7"))
                     ((quote dark)
                      (list "#aa557f" "DarkGreen" "DarkSlateGray" "DarkSlateBlue"))))
           pos
           duration)
      (nconc colors colors)
      (goto-char (point-min))
      (while (setq pos (next-single-property-change (point) 'duration))
        (goto-char pos)
        (when (and (not (equal pos (point-at-eol)))
                   (setq duration (org-get-at-bol 'duration)))
          ;; larger duration bar height
          (let ((line-height (if (< duration 15) 1.0 (+ 0.5 (/ duration 30))))
                (ov (make-overlay (point-at-bol) (1+ (point-at-eol)))))
            (overlay-put ov 'face `(:background ,(car colors) :foreground "black"))
            (setq colors (cdr colors))
            (overlay-put ov 'line-height line-height)
            (overlay-put ov 'line-spacing (1- line-height))))))))

;;(add-hook 'org-agenda-finalize-hook #'org-agenda-log-mode-colorize-block)

#+end_src

** clock & notify

#+begin_src emacs-lisp
(use-package org-clock
  :preface
  (declare-function org-clocking-buffer "org-clock")
  (declare-function org-pomodoro-reset "org-pomodoro")
  :after org evil
  :init
  (evil-define-key 'motion global-map (kbd "<leader>c") 'hydra-org-clock/body)
  (defun my/run-not-clocking-timer ()
    (run-with-timer 0
                    (* 5 60)
                    #'(lambda ()
                        (when (equal (org-clocking-buffer) nil)
                          (progn (alert "din din" :severity 'low :title "clock in" :category "clock"))))))
  :config
  (org-clock-persistence-insinuate)
  ;;(my/run-not-clocking-timer)
  :custom
  ((org-clock-persist 'history)
   (org-clock-idle-time 90)
   (org-clock-mode-line-total 'today)
   (visible-bell t)
   (org-clock-sound "/usr/share/sounds/custom/bell_small.wav")
   (org-clock-continuously t)
   (org-agenda-clockreport-parameter-plist '(:maxlevel 4 :scope agenda :emphasize t :fileskip0 t :stepskip0 t :compact t :hidefiles t :formula % ;; :sort (3 . ?n)
                                                       )))
  :pretty-hydra
  (hydra-org-clock
   (:hint nil :color blue :quit-key "C-g" :exit t :title (with-faicon "clock-o" "Clock"))
   ("Clock"
    (("i" org-mru-clock-in "pick in")
     ("I" org-clock-in "in")
     ("o" org-clock-out "out")
     ("r" org-resolve-clocks "resolve")
     ("c" org-clock-in-last "in last")
     ("j" org-mru-clock-select-recent-task "select recent")
     ("J" org-clock-goto "goto")
     ("e" org-clock-modify-effort-estimate "edit")
     ("q" org-clock-cancel "quit")
     ("?" (org-info "Clocking commands") "info"))
    "Clock report"
    (("d" org-clock-display "display")
     ("R" org-clock-report "report"))
    "Pomodoro"
    (("pp" (org-pomodoro '(16)) "start") ;; (4) - will ask for task interactively
     ("pr" (org-pomodoro-reset) "reset"))
    "Timer"
    (("ts" org-timer-start "start")
     ("tt" org-timer-set-timer "set")
     ("tp" org-timer-pause-or-continue "pause")
     ("tq" org-timer-stop "stop")
     ("t?" (org-info "Timers") "info"))
    "Timer insert"
    (("tm" org-timer "time")
     ("ti" org-timer-item "item")))))

(use-package org-mru-clock
  :ensure
  :after org
  :custom
  ((org-mru-clock-how-many 40)
   (org-mru-clock-completing-read #'ivy-completing-read)))

(use-package org-clock-budget
  :after org evil-collection
  :quelpa (org-clock-budget :repo "Fuco1/org-clock-budget" :fetcher "github")
  :preface
  (defun org-clock-budget-interval-today ()
    "Return the interval representing today."
    (cons
     (format-time-string "%Y-%m-%d 00:00:00")
     (format-time-string "%Y-%m-%d 23:59:59")))
  :config
  (evil-collection-define-key 'normal 'org-clock-budget-report-mode-map (kbd "gr") 'org-clock-budget-report)
  (evil-collection-define-key 'normal 'org-clock-budget-report-mode-map (kbd "zs") 'org-clock-budget-report-sort)
  :custom
  (org-clock-budget-default-sort-column '("BUDGET_WEEK" ratio asc))
  (org-clock-budget-intervals '(
                                ("BUDGET_WEEK" org-clock-budget-interval-this-week)
                                ;; ("BUDGET_TODAY" org-clock-budget-interval-today)
                                )))

(use-package alert
  :ensure
  :custom
  (alert-fade-time 36000) ;; todo - cannot remove fade-away for org-alert
  (alert-default-style 'libnotify))

(use-package alert-toast
  :if (eq system-type 'windows-nt)
  :demand :after alert
  :quelpa (alert-toast :repo "gkowzan/alert-toast" :fetcher "github")
  :custom (alert-default-style 'toast))

;; bad performance
;; (use-package org-alert
;;   :functions (org-alert-enable)
;;   :custom (org-alert-interval (* 12 (* 60 60))) ; every 12 hours
;;   :config (org-alert-enable))

;; doesn't work
;; (use-package org-wild-notifier
;;  :config
;; (with-eval-after-load 'org
;;    (require 'async)
;;    (org-wild-notifier--start)
;;    (org-wild-notifier--stop)
;;    (org-wild-notifier-mode 1)))

;; (use-package org-notifications
;;   :after org
;;   :config
;;   (org-notifications-start))

(use-package org-pomodoro
  :ensure
  :commands (org-pomodoro)
  :after (alert org)
  :custom
  (org-pomodoro-length 50)
  (org-pomodoro-short-break-length 10)
  (org-pomodoro-format "%s")
  (org-pomodoro-short-break-format "%s")
  (org-pomodoro-long-break-format "~~%s~~")
  (org-pomodoro-audio-player "mplayer")
  ; sound-wav cannot play oga - pure noise
  (org-pomodoro-long-break-sound "/usr/share/sounds/custom/bell_small.wav") ;"/usr/share/sounds/freedesktop/stereo/window-attention.oga")
  (org-pomodoro-long-break-sound-args "-af volume=5")
  (org-pomodoro-short-break-sound "/usr/share/sounds/custom/bell_small.wav") ;"/usr/share/sounds/freedesktop/stereo/window-attention.oga")
  (org-pomodoro-short-break-sound-args "-af volume=5")
  (org-pomodoro-finished-sound "/usr/share/sounds/custom/bell_small.wav") ;/usr/share/sounds/freedesktop/stereo/complete.oga")
  (org-pomodoro-finished-sound-args "-af volume=5")
  (org-pomodoro-start-sound "/usr/share/sounds/custom/bell_small.wav") ;"/usr/share/sounds/freedesktop/stereo/complete.oga")
  (org-pomodoro-start-sound-args "-af volume=5")
  :hook
  (org-pomodoro-break-finished . (lambda () (interactive) (org-pomodoro '(16))))
  (org-pomodoro-finished . (lambda () (interactive) (shell-command "~/bin/lock.sh"))))

;; this cannot create alarm for tommorrow
(use-package alarm-clock
  :disabled
  :ensure
  :config
  ;;(alarm-clock-set "06:34" "Wake up!")
  :custom
  (alarm-clock-sound-file "/usr/share/sounds/custom/Freshstart.mp3"))

;; testing
;; (notifications-notify :title "Achtung!"
;;                       :body (format "You have an appointment in %d minutes" 10)
;;                       :app-name "Emacs: Org"
;;                       :sound-file "/usr/share/sounds/custom/bell_small.wav")
#+end_src

** org-journal

#+begin_src emacs-lisp
(use-package org-journal
  :ensure
  :disabled
  :bind (("C-c j j" . org-journal-new-entry))
  :custom
  (org-journal-dir "~/documents/org/journal/")
  (org-journal-date-format "%A, %d %B %Y")
  (org-journal-file-type 'weekly)
  (org-journal-enable-agenda-integration t)
)
#+end_src

** org-gcal

#+begin_src emacs-lisp
(use-package org-gcal
  :disabled
  :ensure
  :after org org-agenda
  :custom
  ((org-gcal-down-days 7)
   (org-gcal-up-days 7)
   (org-gcal-notify-p nil))
  
  ;;(org-gcal-local-timezone "America/Mexico_City")
  :config
  (require 'auth-source-pass)
  (let ((gcal-auth (nth 0 (auth-source-search :host "api.google.com" :requires '(:login :password)))))
    (let ((gcal-secret (plist-get gcal-auth :secret)))
      (setq org-gcal-client-id (plist-get gcal-auth :user)
            org-gcal-client-secret (if (functionp gcal-secret) (funcall gcal-secret) gcal-secret))))
  (setq org-gcal-file-alist '(
                              ("twist.522@gmail.com" . "~/documents/org/gcal/personal.org")
                              ("3fq436g1h8aigd0k0k5jtrv4po@group.calendar.google.com" . "~/documents/org/gcal/sport.org")
                              ("0saojhu0tmsuhvii1vccddgvvk@group.calendar.google.com" . "~/documents/org/gcal/routine.org")
                              ("d9tv5thudt39po9amct0m1jrag@group.calendar.google.com" . "~/documents/org/gcal/nutrition.org")
                              ("family07835897960350574739@group.calendar.google.com" . "~/documents/org/gcal/family.org")
                              ("e7rucoek6h9bu30j8eggn0fdhk@group.calendar.google.com" . "~/documents/org/gcal/trading.org")
                              ))
  (with-eval-after-load 'org-agenda
    (defvar my/agenda-gcal-sync-date nil)
    (defvar my/gcal-sync-date-file (concat user-emacs-directory "persist/agenda-gcal-sync-date"))
    (defun dump-gcal-sync-date-to-file ()
      (my/dump-vars-to-file '(my/agenda-gcal-sync-date) my/gcal-sync-date-file))
    (when (and (not my/agenda-gcal-sync-date) (file-exists-p my/gcal-sync-date-file))
      (load-file my/gcal-sync-date-file))
    (when (not my/agenda-gcal-sync-date)
      (setq my/agenda-gcal-sync-date (format-time-string "%d.%m.%Y"))
      (dump-gcal-sync-date-to-file))
    (when (not is-android) ;;(executable-find "pass")
      (add-hook 'org-agenda-mode-hook
                (lambda()
                  (let ((current-date (format-time-string "%d.%m.%Y")))
                    (when (not (string= current-date my/agenda-gcal-sync-date))
                      (org-gcal-sync)
                      ;; TODO - stick this one here for a moment
                      ;;(org-store-agenda-views)
                      (setq my/agenda-gcal-sync-date current-date)
                      (dump-gcal-sync-date-to-file)
                      )
                    ))
                ))
    )
  )

  
;; org-timeline ;;
;;(use-package org-timeline)
;;(require 'org-timeline)
;;(add-hook 'org-agenda-finalize-hook 'org-timeline-insert-timeline :append)
#+end_src

** org-transclusion

#+begin_src emacs-lisp
(use-package org-transclusion
  :ensure
  :custom
  (org-transclusion-extensions '(org-transclusion-src-lines org-transclusion-font-lock org-transclusion-indent-mode))
  )
#+end_src

** org-ref

#+begin_src emacs-lisp
(use-package org-ref
  :disabled
  :ensure
  )
#+end_src

** org-sync
Simple helper to sync org files into cloud storage - I'm using it only for org files anyway and
I don't want to bloat performance on windows/linux with cloud client apps (e.g. dropbox).
#+begin_src emacs-lisp
(defun rclone-org-bisync ()
  "sync helper using rclone."
  (interactive)
  (require 'org)
  (let ((buf "rclone-org-bisync"))
    (switch-to-buffer buf)
    (erase-buffer)
    (call-process "rclone" nil buf t
                  "bisync" "--verbose" "crypt:org" (concat (getenv "HOME") org-directory))
    (run-with-idle-timer 3 nil `(lambda () (kill-buffer ,buf)))))

;; (add-hook 'kill-emacs-hook #'rclone-org-bisync)

;; (add-hook 'org-mode-hook #'rclone-org-bisync)

(with-eval-after-load 'pretty-hydra
  (pretty-hydra-define+ utils-hydra ()
    ("User" (("ud" rclone-org-bisync "org sync")))))
#+end_src

** org-tags utilities
#+begin_src emacs-lisp
(use-package org-rainbow-tags
  :ensure
  :custom
  (org-rainbow-tags-hash-start-index 10)
  (org-rainbow-tags-extra-face-attributes '(:inverse-video nil :box nil :weight 'bold))
  :hook
  (org-mode . org-rainbow-tags-mode))

(use-package org-pretty-tags
  :ensure
  :hook (org-mode . org-pretty-tags-mode))
#+end_src

** jira

#+begin_src emacs-lisp
(use-package org-jira
  :ensure
  :disabled
  :config
  (setq
   jiralib-url "http://.atlassian.net"
   jiralib-user-login-name "yuri"
   org-jira-custom-jqls '(
                          (:jql "project = \"..\" and sprint = \"Sprint 39\" and resolution = Unresolved order by rank asc"
                                :limit 20
                                :filename "sprint-board")
                          (:jql "project = \"..\" and sprint = \"backlog\" and resolution = Unresolved order by rank asc"
                                :limit 20
                                :filename "tim-data-backlog")
                          )
   )
)

;; confluence support
;; (require 'ox-confluence)
#+end_src

** presentations

#+begin_src emacs-lisp
(use-package org-tree-slide
  :ensure
  :bind (:map org-mode-map (
    ("C-c t t"   . org-tree-slide-mode)
    ("C-c t T d" . org-tree-slide-skip-done-toggle)
    ("C-c t T h" . org-tree-slide-display-header-toggle)
    ("C-c t P s" . org-tree-slide-simple-profile)
    ("C-c t P p" . org-tree-slide-presentation-profile)
    ("C-c t P n" . org-tree-slide-narrowing-control-profile)
)))

(use-package ox-reveal
  :ensure
  :init
  (defun my/create-talk-file()
    "Create an org file for a new talk"
    (interactive)
    (let ((name (read-string "Filename: ")))
      (expand-file-name (format "%s.org" name) (concat org-directory "talks/"))))
  :custom
  (org-reveal-root "/home/twist/.local/src/reveal.js")
  (org-reveal-reveal-js-version 4)
  (org-reveal-highlight-css "%r/plugin/highlight/zenburn.css"))
  :config
  ;this works fine but no speaker notes and highlight plugins
  ;(setq org-reveal-root "https://cdn.jsdelivr.net/npm/reveal.js")
  (add-to-list 'org-capture-templates '("T" "Talk" plain (file my/create-talk-file) "\
,#+OPTIONS: reveal_global_footer:t\n\
,#+REVEAL_THEME: beige\n\
,#+REVEAL_PLUGINS: (highlight notes)\n\
,#+REVEAL_INIT_OPTIONS: slideNumber:true\n\
,#+REVEAL_HLEVEL: 1\n\
,#+TITLE: %^{Title}\n\
,#+AUTHOR: https://git.io/Jvd9c\n\
,#+EMAIL: twist522@gmail.com\n\
,#+OPTIONS: reveal_title_slide:\"<h2>\\%t</h2><h4>%^{Sub Title}</h4>\"\n\
,#+OPTIONS: toc:nil\n\
,#+OPTIONS: num:0\n\
\n* Plan\n\
  :PROPERTIES:\n\
  :UNNUMBERED: t\n\
  :END:\n\
  - %^{point1}\n\
  - %^{point2}\n\
  - %^{point3}\n\
  - %^{point4}\n* Problem\n* Solution\n* Call to Action\n\
  - %^{action1}\n\
  - %^{action2}\n* \n\
:PROPERTIES:\n\
:UNNUMBERED: t\n\
:END:\n\
,#+REVEAL_HTML: <h1>&#x1F603;</h1>") t)
#+end_src

** calfw & calendar

#+begin_src emacs-lisp
;; example - https://cestlaz.github.io/posts/using-emacs-26-gcal/#.WIqBud9vGAk
;; should use ical link - it works only if calendar is public

(use-package calfw-org :ensure
  :pretty-hydra (hydra-org ("Calendar" (("C" cfw:open-org-calendar "calfw-org")))))

(use-package calfw
  :ensure
  :commands cfw:open-calendar-buffer cfw:open-org-calendar
  :custom-face
  (cfw:face-toolbar ((t (:foreground "#1d2021" :background "#1d2021"))))
  (cfw:face-toolbar-button-off ((t (:foreground "Grey50"))))
  (cfw:face-toolbar-button-on ((t (:foreground "DarkOliveGreen1"))))
  :config
  (require 'calfw)
  (require 'calfw-org)
  (setq cfw:org-overwrite-default-keybinding t))

(use-package calfw-ical :ensure)

(use-package calfw-blocks
  :demand :after calfw
  :quelpa (calfw-blocks :fetcher github :repo "ml729/calfw-blocks" :files ("calfw-blocks.el"))
  :custom
  (calfw-blocks-earliest-visible-time '(7 0))
  (calfw-blocks-lines-per-hour 1)
  (calfw-blocks-show-time-grid nil)
  :config
  (require 'calfw-blocks)
  ;; Calendar showing org-agenda entries
  (defun my-open-calendar-agenda ()
    (interactive)
    (cfw:open-calendar-buffer
     :contents-sources
     (list
      (cfw:org-create-source "medium purple"))
     :view 'block-week))
  ;; Calendar showing org entries from files
  (defun my-open-calendar-files ()
    (interactive)
    (cfw:open-calendar-buffer
     :contents-sources
     (list
      (cfw:org-create-file-source "work" "~/documents/org/work.org" "green")
      (cfw:org-create-file-source "personal" "~/documents/org/personal.org" "blue"))
     :view 'block-3-day)))
#+end_src

** org-download

#+begin_src emacs-lisp
(use-package org-download
  :ensure
  :commands (org-download-screenshot)
  :after org
  :bind ("C-S-y" . org-download-screenshot)
  :config
  (org-download-enable)
  ;;(setq org-download-screenshot-method "gnome-screenshot -a -f %s")
  (setq org-download-screenshot-method "scrot -s %s")
  ;;(setq org-download-screenshot-method "sleep 0.2; scrot -s --line mode=edge 'Y-m-d-s_screenshot_$wx$h.jpg' -e 'mv $f ~/Documents/screenshots/; xclip -selection clipboard -t image/png < $f'")
  (when (eq system-type 'windows-nt)
    (setq org-download-screenshot-method "magick convert clipboard: %s")
    (setq org-download-screenshot-file "C:\\Users\\Admin\\Pictures\\screenshot.png"))
  ;;(setq org-download-heading-lvl nil)
  ;; Drag and drop to Dired (?)
  (add-hook 'dired-mode-hook 'org-download-enable)
  (add-hook 'org-mode-hook 'org-download-enable)
  :custom
  (org-download-image-dir "~/documents/org/data")
  (org-image-actual-width '(400))
  (org-download-method 'attach)
  ;;(org-display-remote-inline-images 'cache) ;; this actually works with ssh:// type of remote links
  (org-startup-with-inline-images t))
#+end_src

** org-images
#+begin_src emacs-lisp
(use-package org-inline-image-fix 
  :after org
  :quelpa (org-http-inline-image
           :fetcher github
           :repo "misohena/org-inline-image-fix"
           :files ("org-http-inline-image.el" "org-better-inline-images.el"))
  :config
  (require 'org-better-inline-images)
  (require 'org-http-inline-image)
  (org-http-inline-image-activate))
#+end_src

*** test
[[https://example.com][https://raw.githubusercontent.com/misohena/org-cmenu/main/screenshot/org-cmenu-pretty.png]]

** easydraw
#+begin_src emacs-lisp
(use-package el-easydraw
  :ensure
  :after org
  :quelpa (edraw-org
           :fetcher github
           :repo "misohena/el-easydraw")
  :config
  (require 'edraw-org)
  (edraw-org-setup-default))
#+end_src

*** test
# [[edraw:data=H4sIAP7qbGQAA3VSwW6DMAz9lci9bFKBJDBUKsJlV/YRtEkhKg1VkhW6r58baNdJ28F5cp6d92yldJeWjFr6TsBbToF0SredF5BxTC7KOj0YASxmQKZTb5yAzvvzNknGcYzHNB5sm3BKaYIPLSXbqdfm+FchK4oiCSxUpVV7/7/0JADPazgPuu8F2HbXvPAsX7O3TQgaF5S/AnHeDkclwAxGAdFSgJK2GaNdsz+2dvg0EkhSle0zNcjr3cLv9llrJSU2WTTBUN9eZwzp7CrgYp7xZ/M0iJ0b3z1eXuHYd5vR0pTdpWZZdPbBOV3zjL6niCmlJM0x3zywzrLA17ifNUNMMUcfNUee5bRmN8Q6li3I5/uZDra8mjw5DMZHh+akexzENcZFTll9gJlw+gstsw2QW3HUmH03WAEnLWX/sx/OedhHNq8DfwBUXjlfJreuqkxaDPwS1TcUHDGtYQIAAA==]]

** utilities

#+begin_src emacs-lisp
(defun change-tag (old new)
  (when (member old (org-get-tags))
    (org-toggle-tag new 'on)
    (org-toggle-tag old 'off)))

(defun org-rename-tag (old new)
  (interactive "scurrent tag: \nsnew name: ")
  (org-map-entries
   (lambda () (change-tag old new))
   (format "+%s" old)
   'agenda-with-archives))

;; (defun my/org-ql-parents ()
;;   (interactive)
;;   (org-ql-search (org-agenda-files) '(todo) :super-groups '((:auto-parent t))))

(defun my/org-get-parent-goal ()
  (interactive)
  (-when-let* ((goal-link (org-entry-get (point) "GOAL" t)))
    (org-link-display-format goal-link)
    ;; (save-window-excursion
    ;;   (org-link-open-from-string goal-link)
    ;;   (org-get-heading 'notags 'notodo))
    ))

(defun my/org-set-goal ()
  (interactive)
  (ivy-read "Goal: " (org-map-entries
                           (lambda () (org-element-property :title (org-element-at-point)))
                           "+goal+current+TODO=\"GOAL\"" (list (concat org-directory "goals.org")))
            :action (lambda (goal)
                      (with-ivy-window
                        (when goal
                          (let ((goal-link (format "[[file:%sgoals.org::*%s][%s]]" org-directory goal goal)))
                            (if (string= (buffer-name) "*Org Agenda*")
                                ;; below taken from org-agenda-set-property
                              (let* ((marker (org-get-at-bol 'org-hd-marker))
                                     (buffer (marker-buffer marker))
	                                 (pos (marker-position marker)))
                                (org-with-remote-undo buffer
                                  (with-current-buffer buffer
                                    (widen)
                                    (goto-char pos)
	                                (org-show-context 'agenda)
                                    (org-set-property "GOAL" goal-link)
                                    ))
                                (org-agenda-redo t)
                                )
                              (org-set-property "GOAL" goal-link)
                              )
                            )
                          )))))


(use-package orgtbl-join :ensure)
#+end_src

** links WIP
#+begin_src emacs-lisp
(defun cfdy/org-links ()
  (interactive)
  (save-excursion
    (save-restriction
      (kill-matching-buffers-no-ask "\\*urls\\*")
      (org-narrow-to-subtree (org-element-at-point))
      (org-element-map (org-element-parse-buffer) 'link
        (lambda (link)
          ;;(message "%s" link)
          (message "%s" (org-element-property :raw-link link))
          (with-current-buffer (get-buffer-create "*urls*")
            (goto-char (point-max))
            (insert (org-element-property :raw-link link))
            (insert "\n"))
          )
        ;; (when (string= (org-element-property :type link) "file")
        ;;   (org-element-property :path link))
        )
      (pop-to-buffer "*urls*")
      )))
#+end_src

** plantuml

#+begin_src emacs-lisp
(use-package plantuml-mode
  :ensure
  :after org
  :mode "\\.plantuml\\'"
  :custom
  (plantuml-default-exec-mode 'jar)
  (plantuml-jar-path org-plantuml-jar-path))
#+end_src

** mermaid
#+begin_src emacs-lisp
(use-package mermaid-mode
  :ensure
  :config
  (setq mermaid-mmdc-location "podman")
  (setq mermaid-flags "run -u 1000 -v /tmp:/tmp ghcr.io/mermaid-js/mermaid-cli/mermaid-cli:9.1.6")
  ;; (setq mermaid-flags "")
  ;; (setq mermaid-mmdc-location "podman run -u 1000 -v /tmp:/tmp ghcr.io/mermaid-js/mermaid-cli/mermaid-cli:9.1.6")
  )
#+end_src

** gnuplot

#+begin_src emacs-lisp
(use-package gnuplot
  :ensure
  :config
  (setq gnuplot-program-version "5.4") ;; auto-determine version within gnuplot.el doesn't work
  (autoload 'gnuplot-mode "gnuplot" "gnuplot major mode" t)
  (autoload 'gnuplot-make-buffer "gnuplot" "open a buffer in gnuplot mode" t)
  ;; this line automatically causes all files with the .gp extension to be loaded into gnuplot mode
  (setq auto-mode-alist (append '(("\\.gp$" . gnuplot-mode)) auto-mode-alist))
  ;; This line binds the function-9 key so that it opens a buffer into gnuplot mode
  (global-set-key [(f9)] 'gnuplot-make-buffer)
)
#+end_src

** prettify

#+begin_src emacs-lisp
;; prettify
;; todo - this destroys some of the org-mode and evil bindings for some reason
(defun my/pretty-org ()
  "Beautify Org Checkbox Symbol"
  (push '("[ ]" . "☐" ) prettify-symbols-alist)
  (push '("[x]" . "🗵" ) prettify-symbols-alist)
  (push '("[v]" . "✓" ) prettify-symbols-alist);; "🗹☑"
  (push '("[~]" . "🗘" ) prettify-symbols-alist) ;; ❍ 🔃
  ;; (push '("#+BEGIN_SRC" . "➤") prettify-symbols-alist) ;; ➤ 🖝 ➟ ➤ ✎
  ;; (push '("#+END_SRC" . "⏹") prettify-symbols-alist) ;; ⏹ □
  ;; (push '("#+begin_src" . "➤") prettify-symbols-alist) ;; ➤ 🖝 ➟ ➤ ✎
  ;; (push '("#+end_src" . "⏹") prettify-symbols-alist) ;; ⏹ □
  ;; (push '("#+BEGIN_QUOTE" . "«") prettify-symbols-alist) ;; ➤ 🖝 ➟ ➤ ✎
  ;; (push '("#+END_QUOTE" . "»") prettify-symbols-alist) ;; ⏹ □
  (push '(":PROPERTIES:" . "π") prettify-symbols-alist) ;; ➤ 🖝 ➟ ➤ ✎
  (push '(":LOGBOOK:" . "λ") prettify-symbols-alist) ;; ➤ 🖝 ➟ ➤ ✎
  (push '(":END:" . "ω") prettify-symbols-alist) ;; ➤ 🖝 ➟ ➤ ✎
  ;; (push '("[#A]" . "⚡" ) prettify-symbols-alist) ;; ⚡  ❗
  ;; (push '("[#B]" . "⬆" ) prettify-symbols-alist)
  ;; (push '("[#C]" . "❖" ) prettify-symbols-alist)
  ;; (push '("[#D]" . "⬇" ) prettify-symbols-alist)
  (push '("<=" . "≤") prettify-symbols-alist)
  (push '("part_d" . "∂") prettify-symbols-alist)
  (push '("Gamma" . "Γ") prettify-symbols-alist)
  (push '("sigmoid" . "σ") prettify-symbols-alist)
  (push '("integral" . "∫") prettify-symbols-alist)
  (prettify-symbols-mode)
  )

(add-hook 'org-mode-hook #'my/pretty-org)

;; (defun yant/str-to-glyph (str)
;;   "Transform string into glyph, displayed correctly."
;;   (let ((composition nil))
;;     (dolist (char (string-to-list str)
;;     (nreverse (cdr composition)))
;;       (push char composition)
;;       (push '(Br . Bl) composition))))
;;(?▤ org-specific ":LOGBOOK:" (org-mode))
;;(?⚙ org-specific ":PROPERTIES:" (org-mode))
;;(?⏏ org-specific ":END:" (org-mode))
;;((yant/str-to-glyph "⚑") org-specific "\\(?:^*+ +\\)\\(\\<WAITING\\>\\)" (org-mode) 1)
;;((yant/str-to-glyph "♲") org-specific "\\(?:^*+ +\\)\\(\\<HOLD\\>\\)" (org-mode) 1)
;;((yant/str-to-glyph "☠D") org-specific "\\<DEADLINE:" (org-mode))
;;((yant/str-to-glyph "◴S") org-specific "\\<SCHEDULED:" (org-mode))))))

(use-package org-bullets
  :disabled
  :ensure
  :hook (org-mode . (lambda() (org-bullets-mode 1))))

(use-package org-superstar
  :ensure
  ;; aka org-modern org-modern-hide-stars
  ;; :custom
  ;; (org-superstar-remove-leading-stars t)
  :hook
  (org-mode . (lambda () (org-superstar-mode 1))))

(use-package org-modern
  :ensure
  :custom
  (org-modern-todo nil)
  ;; it is actually ugly
  ;;(org-modern-hide-stars t)
  ;;(org-modern-keyword nil)
  ;;(org-modern-checkbox nil)
  ;;(org-modern-table nil)
  (org-modern-priority nil)
  (org-modern-star 'replace)
  :config
  (set-face-background 'org-modern-tag (face-attribute 'default :background))
  :hook
  (org-mode . org-modern-mode))

(use-package org-fancy-priorities
  ;;:disabled ;; prettify-symbols-mode above doesn't change org-agenda for some reason
  :diminish
  :ensure
  :hook
  (org-mode . org-fancy-priorities-mode)
  :config
  (setq org-fancy-priorities-list '("⚡" "⬆" "❖" "⬇"))) ;;☕

;; :EXPERIMENT:
(use-package org-link-beautify
  :ensure
  ;;:config
  ;; override after pcase in file:elpa/org-link-beautify-20240312.529/org-link-beautify.el::org-link-beautify--preview-url
  ;; (org-link-beautify--preview-url-archive url (list "microsoft-edge-dev" "--headless" "--disable-gpu" (concat "--screenshot=" thumbnail-file) url))
  ;; and 
  ;; (and org-link-beautify-url-preview (org-url-p (concat type ":" path)))
  ;; and
  ;;(thumbnail-filename (format "org-link-beautify-%s.png" (string-replace "/" "-" path)))
  :custom
  (org-link-beautify-image-preview t)
  (org-link-beautify-url-preview-size 256)
  (org-link-beautify-display-overlay-info t)
  (org-link-beautify-text-preview t)
  ;; this is not implemented yet
  (org-link-beautify-url-preview t)
  (org-link-beautify-enable-debug-p t)
  )

(use-package org-appear
  :ensure
  :hook
  (org-mode . org-appear-mode))
#+end_src
** others

#+begin_src emacs-lisp

(use-package org-sidebar
  :ensure)

(use-package org-ql
  :ensure
  :config
  (require 'org-ql-search))

(use-package org-super-agenda
  :ensure
  :demand :after evil general org-agenda
  :general (:states 'motion :keymaps 'org-super-agenda-header-map
                    "TAB" #'origami-toggle-node)
  :config
  (org-super-agenda-mode)
  ;;(setq org-super-agenda-header-map (copy-keymap org-agenda-mode-map))
  ;; in-progress: I have no idea why bindings in org-super-agenda-header-map don't work
  (setq org-super-agenda-header-map (make-sparse-keymap))
  (general-def '(normal motion) org-agenda-keymap "<tab>" 'origami-toggle-node)
  (general-def '(normal motion) org-super-agenda-header-map "<tab>" 'origami-toggle-node)
  (general-def '(normal motion) org-super-agenda-header-map "TAB" 'origami-toggle-node)
  (general-def '(normal motion) org-super-agenda-header-map "j" 'org-agenda-next-line)
  (general-def '(normal motion) org-super-agenda-header-map "k" 'org-agenda-prev-line)
  ;; (general-def '(normal motion) org-super-agenda-header-map "k" 'org-agenda-prev-line)
  ;; (general-def '(normal motion) org-super-agenda-header-map "SPC" (general-simulate-key "<leader>"))
  )

(use-package org-roam
  :disabled
  :ensure
  :init (setq org-roam-v2-ack t) ;; I want to silence bytecompiler
  :custom (org-roam-directory "~/documents/org/")
  :bind
  (:map org-roam-mode-map
        (("C-c n l" . org-roam)
         ("C-c n f" . org-roam-find-file)
         ("C-c n g" . org-roam-graph))
        :map org-mode-map
        (("C-c n i" . org-roam-insert))
        (("C-c n I" . org-roam-insert-immediate))))

;; experimenting
(use-package outshine
  :quelpa (outshine :fetcher github :repo "alphapapa/outshine"))
#+end_src

** individual visibility
Choosing initial visibility per src block (for now disabled, using STARTUP:hideblocks per file)
#+BEGIN_SRC emacs-lisp :hidden :tangle no
(defun individual-visibility-source-blocks ()
  "Fold some blocks in the current buffer."
  (interactive)
  (org-show-block-all)
  (org-block-map
   (lambda ()
     (let ((case-fold-search t))
       (when (and
              (save-excursion
                (beginning-of-line 1)
                (looking-at org-block-regexp))
              (cl-assoc
               ':hidden
               (cl-third
                (org-babel-get-src-block-info))))
         (org-hide-block-toggle))))))

(add-hook
 'org-mode-hook
 (function individual-visibility-source-blocks))
#+END_SRC

** personal configs
#+begin_src emacs-lisp
(setq org-directory "~/documents/org/")
;; (with-eval-after-load 'org
;;   )
(load-file (concat org-directory "config.el"))
#+end_src

* * *prog
** prog-mode
#+begin_src emacs-lisp
(use-package prog-mode
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook
   'after-init-hook
   #'(lambda ()
       (add-hook
        'prog-mode-hook
        #'(lambda ()
            (highlight-symbol-mode)
            (highlight-symbol-nav-mode)
            ;; navigate snakeCase
            (subword-mode)
            (show-paren-local-mode)
            (unless (eq major-mode 'emacs-lisp-mode) (toggle-truncate-lines 1))
       ))))
  )

(use-package nlinum
  :ensure
  :disabled ;; lags enormously with pixel-precision-scroll
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook #'(lambda () (add-hook 'prog-mode-hook #'linum-mode)))
  )

(use-package page-break-lines
  :ensure
  :diminish (page-break-lines-mode . "^L"))

;; show indents in all modes
;; bad performance
;;(use-package indent-guide
;;  :hook (prog-mode . indent-guide-mode))

(use-package aggressive-indent :ensure
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook #'(lambda ()
                                 (add-hook
                                  'emacs-lisp-mode-hook #'aggressive-indent-mode)))
  :hook
  (css-mode . aggressive-indent-mode))

(use-package editorconfig :ensure
  ;; :demand :after prog-mode
  :diminish ;; " EC"
  :config (editorconfig-mode 1))

;; bad performance, really bad
(use-package highlight-indentation :ensure :disabled)
#+end_src
** tags
#+begin_src emacs-lisp
(use-package ggtags :ensure)
#+end_src
** git

#+begin_src emacs-lisp
(use-package magit
  :ensure
  :ensure-system-package git
  ;;:custom (magit-credential-cache-daemon-socket "/home/twist/.git-credential-cache/socket")
  ;;:config
  ;;(require 'magit-gh-pulls)
  ;;(add-hook 'magit-post-refresh-hook 'diff-hl-magit-post-refresh)
  :after evil general
  :general
  (magit-mode-map "SPC" nil)
  (magit-mode-map "e" nil)
  (normal magit-mode-map "?" 'magit-dispatch)
  (normal magit-section-mode-map "M-1" nil "M-2" nil "M-3" nil "M-4" nil) ;; free for tab-bar
  (magit-section-mode-map "M-1" nil "M-2" nil "M-3" nil "M-4" nil)
  (:states '(normal motion) :keymaps 'global-map (kbd "<leader>g") 'hydra-git/body)
  :commands (hydra-git/body)
  :custom
  ((vc-follow-symlinks t)  ;; this will prevent asking when visiting git-controlled symlink
   (magit-display-buffer-function 'magit-display-buffer-same-window-except-diff-v1))
  :pretty-hydra
  (hydra-git
   (:hint nil :color teal :quit-key "q" :title (with-alltheicon "git" "Git" 1 -0.05))
   ("Action"
    (("b" magit-blame-addition "blame")
     ("c" magit-clone "clone")
     ("i" magit-init "init")
     ("t" git-timemachine "time machine")
     ("l" magit-log-buffer-file "commit log (current file)")
     ("L" magit-log-current "commit log (project)")
     ("g" magit-status "status")))))

(use-package magithub
  :disabled
  :ensure :after magit)

(use-package git-timemachine
  :ensure
  :after evil
  :config
  (evil-make-overriding-map git-timemachine-mode-map 'normal)
  ;; force update evil keymaps after git-timemachine-mode loaded
  (add-hook 'git-timemachine-mode-hook #'evil-normalize-keymaps))

(use-package gh :ensure :disabled)

(use-package forge :disabled :ensure :demand :after magit)

(use-package git-modes :ensure)

(use-package magit-todos :ensure
  :disabled ;; hl-todo problem
  :after magit :hook (magit-mode . magit-todos-mode)
  :unless (eq system-type 'windows-nt))

(use-package magit-delta
  :ensure :disabled ;; ugly,buggy
  :after magit
  :hook (magit-mode . magit-delta-mode))

;; increase performance (on windows especially)
;; (use-package magit-libgit :ensure :demand :after magit
;;   :unless (eq system-type 'windows-nt))

(use-package magit-gh-pulls
  :disabled
  :ensure
  :functions (gh-profile-current-profile gh-auth-remember) ;; actually coming from gh
  :after magit
  ;;:hook ((magit-mode . magit-gh-pulls-mode)
  ;;       ;;(magit-mode . magit-gh-pulls-reload)
  ;;       )
  :config
  (gh-auth-remember (gh-profile-current-profile) :token (auth-source-pass-get "oauth-token" "github.com/thatwist"))
  (gh-auth-remember (gh-profile-current-profile) :username "thatwist"))

                                        ; don't need as it is in evil-collection
                                        ;(use-package evil-magit
                                        ;  :after evil magit
                                        ;  :config
                                        ;  (setq evil-magit-state 'motion))

(use-package ediff
  :preface
  (defun my/ediff-prepare ()
    "To make proper load order and turn off unnecessary stuff for ediff"
    (require 'evil-collection)
    (require 'ediff)
    (require 'ediff-util)
    (eval-after-load 'golden-ratio (golden-ratio-mode -1))
    (eval-after-load 'tab-line (global-tab-line-mode -1)))
  (defun my/ediff-diff (a b)
    "To be run as eval param from external process for diff"
    (my/ediff-prepare)
    (ediff a b))
  (defun my/ediff-merge (a b c)
    "To be run as eval param from external process for merge"
    (my/ediff-prepare)
    (ediff-merge-files-with-ancestor a b c))
  (defun my/ediff-copy-both-to-C ()
    "Copy both A then B into merge buffer."
    (interactive)
    (ediff-copy-diff ediff-current-difference nil 'C nil
                     (concat
                      (ediff-get-region-contents ediff-current-difference 'A ediff-control-buffer)
                      (ediff-get-region-contents ediff-current-difference 'B ediff-control-buffer))))
  :commands (ediff)
  :after evil-collection
  :config
  (message "ediff config")
  (evil-collection-ediff-setup)
  (add-hook 'ediff-keymap-setup-hook ;; todo - move it to evil-collection/leader configuration
            (lambda () (general-def 'normal ediff-mode-map "SPC" (general-simulate-key "<leader>"))))
  (setq ediff-control-frame-parameters (cons '(tab-bar-lines . 0) ediff-control-frame-parameters))
  (when (eq system-type 'windows-nt)
    (setq ediff-diff-program "C:\\Program Files\\Git\\usr\\bin\\diff.exe")
    (setq diff-command "\"C:\\Program Files\\Git\\usr\\bin\\diff.exe\""))
  :hook (ediff-keymap-setup . (lambda () (define-key ediff-mode-map "c" 'my/ediff-copy-both-to-C)))
  :custom
  (ediff-window-setup-function 'ediff-setup-windows-default) ;'ediff-setup-windows-plain ; ediff use same frame
  (ediff-merge-split-window-function 'split-window-vertically)
  ;; maybe one day I will turn off tab-line-mode locally just in ediff control window
  ;; :hook (ediff-startup-hook . (lambda ()
  ;;                               (make-local-variable 'tab-line-mode)
  ;;                               ()))
  )

;; diff-hl requires this
(use-package smartrep)

(use-package diff-hl
  :ensure
  :after smartrep
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook #'(lambda () (add-hook 'prog-mode-hook #'diff-hl-mode)))
  :hook
  (vc-dir-mode-hook . diff-hl-mode)
  ;;:custom-face
  ;; (diff-hl-change ((t (:background "#333355" :foreground "blue3" :width extra-expanded))))
  ;; (diff-hl-delete ((t (:inherit diff-removed :foreground "red3" :width extra-expanded))))
  ;; (diff-hl-insert ((t (:inherit diff-added))))
  )

;; github gist integration
;;(use-package gist)
#+end_src
** smerge hydra

#+begin_src emacs-lisp
(use-package smerge-mode
  :after evil
  :init (evil-define-key 'motion global-map (kbd "<leader>M-m") 'hydra-smerge/body)
  :pretty-hydra
  (hydra-smerge
    (:quit-key "q" :exit nil :color blue :hint nil :pre (smerge-mode 1))
    ("Move"
     (("n" smerge-next)
      ("p" smerge-prev))
     "Keep"
     (("a" smerge-keep-all)
      ("b" smerge-keep-base)
      ("u" smerge-keep-upper)
      ("l" smerge-keep-lower)
      ("RET" smerge-keep-current))
     "Diff"
     (("C" smerge-combine-with-next)
      ("E" smerge-ediff)
      ("R" smerge-refine)
      ("r" smerge-resolve))
     "Pair"
     (("<" smerge-diff-base-upper)
      ("=" smerge-diff-upper-lower)
      (">" smerge-diff-base-lower)))))
#+end_src

** flycheck

#+begin_src emacs-lisp
(use-package flycheck-projectile
  :ensure :demand :after (flycheck projectile))

(use-package flycheck
  :ensure
  :after evil general
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook #'(lambda () (add-hook 'prog-mode-hook #'flycheck-mode)))
  :diminish ;; " F"
  ;; prog-mode in this list doesn't work against child modes
  ;;(cutsomize-set-variable 'flycheck-global-modes '(prog-mode markdown-mode)))
  :custom
  (flycheck-error-message-buffer " *Flycheck error messages*")
  (flycheck-checker-error-threshold 1000)
  :general (:states 'motion "<leader>F" 'hydra-flycheck/body)
  :pretty-hydra
  (hydra-flycheck
   (:hint nil :color teal :quit-key "q" :title (with-faicon "plane" "Flycheck" 1 -0.05))
   ("Checker"
    (("?" flycheck-describe-checker "describe")
     ("d" flycheck-disable-checker "disable")
     ("m" flycheck-mode "mode")
     ("s" flycheck-select-checker "select"))
    "Errors"
    (("k" flycheck-previous-error "previous" :color pink)
     ("j" flycheck-next-error "next" :color pink)
     ("f" flycheck-buffer "check")
     ("l" flycheck-list-errors "list")
     ("L" flycheck-projectile-list-errors "list project"))
    "Other"
    (("M" flycheck-manual "manual")
     ("v" flycheck-verify-setup "verify setup")))))

(use-package flycheck-posframe
  :ensure
  :config
  (unless is-android
    (add-hook 'flycheck-mode-hook #'flycheck-posframe-mode))
  )

;; WIP - doesn't really work at the moment
(use-package sideline
  :disabled ;; problematic on android termux?
  :ensure
  :hook (flycheck-mode . sideline-mode)
  :init
  (setq sideline-backends-right '(sideline-flycheck)))

(use-package sideline-flycheck
  :disabled ;; problematic on android termux?
  :ensure
  :hook (flycheck-mode . sideline-flycheck-setup))
#+end_src

** next-error hydra
Disabling this one as flycheck hydra is enough
#+begin_src emacs-lisp :tangle no
(defhydra hydra-next-error (:hint nil)
    "
Compilation errors:
_j_: next error        _h_: first error    _q_uit
_k_: previous error    _l_: last error
"
    ("`" next-error     nil)
    ("j" next-error     nil :bind nil)
    ("k" previous-error nil :bind nil)
    ("h" first-error    nil :bind nil)
    ("l" (condition-case err
             (while t
               (next-error))
           (user-error nil))
     nil :bind nil)
    ("q" nil            nil :color blue))
#+end_src

** jump-to
#+begin_src emacs-lisp
(use-package xref :ensure :pin gnu)

(use-package dumb-jump
  :functions xref-show-definitions-completing-read
  :ensure
  :init (setq xref-show-definitions-function #'xref-show-definitions-completing-read)
  :config (add-hook 'xref-backend-functions #'dumb-jump-xref-activate))

;; testing
(unless is-android
  (use-package back-button
    :ensure
    ;;:demand
    :diminish ;; " <"
    :general
    ;; (:keymaps '(evil-normal-state-map)
    ;;           "C-o" 'back-button-global-backward
    ;;           "C-i" 'back-button-global-forward)
    ;; ("M-<left>" 'back-button-local-backward
    ;;  "M-<right>" 'back-button-local-forward
    ;;  "M-S-<left>" 'back-button-global-backward
    ;;  "M-S-<right>" 'back-button-global-forward)
    ("C-<" 'back-button-local-backward
     "C->" 'back-button-local-forward
     "C-S-<" 'back-button-global-backward
     "C-S->" 'back-button-global-forward)
    :config
    (back-button-mode 1)
    ))

;; testing
(use-package smart-jump
  :ensure t
  :commands (smart-jump-go smart-jump-back smart-jump-references)
  :disabled
  ;; :init
  ;; (with-eval-after-load 'general
  ;;   (general-define-key
  ;;    :states '(normal visual motion)
  ;;    :keymaps 'override
  ;;    "M-." 'smart-jump-go
  ;;    "M-," 'smart-jump-back
  ;;    "M-?" 'smart-jump-references))
  :config
  (smart-jump-register :modes '(js2-mode rjsx-mode))
  (smart-jump-register :modes 'anaconda-mode
                       :jump-fn 'anaconda-mode-find-definitions
                       :pop-fn 'anaconda-mode-go-back
                       :refs-fn 'anaconda-mode-find-references
                       :heuristic 'point
                       :async 600)
  (smart-jump-register :modes '(emacs-lisp-mode lisp-interaction-mode)
                       :jump-fn 'elisp-slime-nav-find-elisp-thing-at-point
                       :pop-fn 'pop-tag-mark
                       :should-jump t
                       :heuristic 'error
                       :async nil)
  (defun smart-jump-peek ()
    "Peek at definition."
    (interactive)
    (smart-jump-make-peek-frame 'smart-jump-go))

  (defun smart-jump-make-peek-frame (find-definition-function &rest args)
    "Make a new frame for peeking definition. Credits to @tuhdo. http://tuhdo.github.io/emacs-frame-peek.html"
    (let (doc-frame
          x y
          ;; 1. Find the absolute position of the current beginning of the
          ;; symbol at point, in pixels.
          (abs-pixel-pos (save-excursion
                           ;; (beginning-of-thing 'symbol)
                           (beginning-of-line)
                           (window-absolute-pixel-position))))
      (setq x (car abs-pixel-pos))
      (setq y (+ (cdr abs-pixel-pos)
                 (frame-char-height)))

      ;; 2. Create a new invisible frame, with the current buffer in it.
      (setq doc-frame (make-frame '((name . "*SmartJump Peek*")
                                    (width . 80)
                                    (visibility . nil)
                                    (height . 20)
                                    (min-width  . t)
                                    (min-height . t)
                                    (border-width . 0)
                                    (internal-border-width . 0)
                                    (vertical-scroll-bars . nil)
                                    (horizontal-scroll-bars . nil)
                                    (left-fringe . 0)
                                    (right-fringe . 0)
                                    (tool-bar-lines . 0)
                                    (line-spacing . 0)
                                    (unsplittable . t)
                                    (no-other-frame . t)
                                    (no-special-glyphs . t))))

      ;; 3. Position the new frame right under the beginning of the
      ;; symbol at point.
      (set-frame-position doc-frame x y)

      ;; 4. Jump to the symbol at point.
      (with-selected-frame doc-frame
        (apply find-definition-function args)
        (recenter-top-bottom 0))

      ;; 5. Make frame visible again.
      (make-frame-visible doc-frame)))
  )

;; testing
(use-package better-jumper
  :ensure
  :after evil
  :custom (better-jumper-use-evil-jump-advice t)
  :config
  (better-jumper-mode +1)
  (with-eval-after-load 'evil-maps
    (define-key evil-motion-state-map (kbd "C-o") 'better-jumper-jump-backward)
    (define-key evil-motion-state-map (kbd "C-i") 'better-jumper-jump-forward)))
#+end_src

** elisp
*** elisp cheatsheet

car/cdr reminder
#+begin_src emacs-lisp :tangle no
(cdr '(1 . 2))
;2

(cdr '(1 2))
;(2)
; equivalent
(cdr '(1 . (2 . nil)))
;(2)
#+end_src

*** editing
#+begin_src emacs-lisp
(use-package paredit
  :ensure
  :diminish "()"
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook
            #'(lambda ()
                (add-hook 'emacs-lisp-mode-hook #'enable-paredit-mode)
                (add-hook 'lisp-interaction-mode-hook
                          #'(lambda()
                              (enable-paredit-mode)
                              (define-key paredit-mode-map (kbd "C-j") nil)))))
  (with-eval-after-load 'evil
    (evil-define-key 'normal 'lisp-interaction-mode (kbd "C-j") 'eval-print-last-sexp))
  )

(use-package evil-paredit
  :ensure
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook #'(lambda () (add-hook 'emacs-lisp-mode-hook #'evil-paredit-mode)))
  )

;; can use '(' to navigate up sexp
(use-package evil-cleverparens
  :ensure
  :diminish " {}"
  :hook (paredit-mode . evil-cleverparens-mode)
  :general
  ((normal visual motion) evil-cleverparens-mode-map
   ;; free up for my buffer/window movements
   "M-y" nil "M-H" nil "M-L" nil "M-k" nil "M-j" nil "M-h" nil "M-o" nil "M-i" nil "M-l" nil "M-m" nil)
  :custom
  (evil-cleverparens-move-skip-delimiters t)
  (evil-cleverparens-swap-move-by-word-and-symbol nil) ;; this will swap bewBEW movements - I don't like it as I use subword mode
  (evil-cleverparens-use-additional-movement-keys t))

;; didn't like it
;;(use-package lispy
;;  :init
;;  (add-hook 'emacs-lisp-mode-hook (lambda () (lispy-mode 1)))
;;  :config (require 'evil-lispy))
;;
;;(use-package evil-lispy)

(unless (eq system-type 'windows-nt)
  (use-package elisp-autofmt
    :ensure
    :config
    ;; otherwise during fresh install it may cycle autoloading
    (add-hook
     'after-init-hook
     #'(lambda ()
         (add-hook
          'lisp-interaction-mode-hook
          #'(lambda ()
              "Makes it possible to use evil's '==' for fmt."
              (setq indent-line-function 'elisp-autofmt-region-dwim)))))
    ))
#+end_src

*** edebug
hydra came from [[https://github.com/kaushalmodi/.emacs.d/blob/master/setup-files/setup-elisp.el][here]]
#+begin_src emacs-lisp
(use-package edebug
  :after evil
  :init (evil-define-key 'motion emacs-lisp-mode-map (kbd "<leader>E") 'hydra-edebug/body)
  :commands (hydra-edebug/body)
  :bind (:map edebug-mode-map ("?" . hydra-edebug/body))
  :config
  ;; use <normal> 's' instead
  (define-key edebug-mode-map (kbd "<SPC>") nil)
  :pretty-hydra
  (hydra-edebug
   (:color amaranth :hint none :quit-key "q" :title (with-faicon "wrench" "Edebug" 1 -0.05))
   (""
    (("<SPC>" edebug-step-mode)
     ("n"     edebug-next-mode)
     ("g"     edebug-go-mode)
     ("G"     edebug-Go-nonstop-mode)
     ("t"     edebug-trace-mode)
     ("T"     edebug-Trace-fast-mode)
     ("c"     edebug-continue-mode)
     ("C"     edebug-Continue-fast-mode)
     ("f"     edebug-forward-sexp)
     ("h"     edebug-goto-here)
     ("I"     edebug-instrument-callee)
     ("i"     edebug-step-in)
     ("o"     edebug-step-out))
    "breakpoints"
    (("b"     edebug-set-breakpoint)
     ("u"     edebug-unset-breakpoint)
     ("B"     edebug-next-breakpoint)
     ("x"     edebug-set-conditional-breakpoint)
     ("X"     edebug-set-global-break-condition))
    "evaluation"
    (("r"     edebug-previous-result)
     ("e"     edebug-eval-expression)
     ("l"     edebug-eval-last-sexp)
     ("E"     edebug-visit-eval-list))
    "views"
    (("w"     edebug-where)
     ("d"     edebug-pop-to-backtrace)
     ("p"     edebug-bounce-point)
     ("v"     edebug-view-outside)        ; maybe obsolete??
     ("P"     edebug-view-outside)        ; same as v
     ("W"     edebug-toggle-save-windows))
    "quitting and stopping"
    (("q"     top-level :color blue)
     ("Q"     edebug-top-level-nonstop :color blue)
     ("a"     abort-recursive-edit :color blue)
     ("U"     edebug-remove-instrumentation :color blue)
     ("S"     edebug-stop :color blue)))))
#+end_src

*** elisp-hydra

#+begin_src emacs-lisp
(use-package emacs-lisp-mode
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook
   'after-init-hook
   #'(lambda () (add-hook 'emacs-lisp-mode-hook #'(lambda () (toggle-truncate-lines -1)))))
  :mode-hydra
  (emacs-lisp-mode
   nil
   ("Eval"
    (("b" eval-buffer "buffer")
     ("e" eval-defun "defun")
     ("r" eval-region "region"))
    "Debug"
    (("E" hydra-edebug/body "edebug"))
    "REPL"
    (("I" ielm "ielm"))
    "Test"
    (("t" ert "prompt")
     ("T" (ert t) "all")
     ("F" (ert :failed) "failed"))
    "Doc"
    (("f" describe-function "function")
     ("v" describe-variable "variable")
     ("i" info-lookup-symbol "info lookup")))))
#+end_src

** completion
#+begin_src emacs-lisp
(use-package company :ensure
  :pin gnu ;; latest company as of 2024-07-18 doesn't work with company-fuzzy
  :diminish
  :commands (company-indent-or-complete-common)
  :custom
  (tab-always-indent 'complete)
  ;; (company-require-match nil) ;; Don't require match, so you can still move your cursor as expected.
  (company-require-match 'company-explicit-action-p)
  (company-tooltip-align-annotations t) ;; Align annotation to the right side.
  (company-dabbrev-downcase nil) ;; No downcase when completion.
  ;; (tab-first-completion 'word-or-paren-or-punct)
  (company-dabbrev-code-ignore-case nil)
  ;;(company-dabbrev-downcase nil)
  (company-idle-delay 0.3)
  (company-minimum-prefix-length 2)
  (company-selection-wrap-around t)
  (company-show-quick-access t)
  (company-backends
   '((company-capf :with company-yasnippet company-dabbrev-code)
     (company-yasnippet company-dabbrev-code)
     (company-keywords company-files company-etags)
     company-dabbrev
     ;; company-emoji
     ))
  :hook
  (after-init . global-company-mode)
  (company-mode . company-tng-mode) ;; tng=tab-and-go
  ;; (company-mode . company-fuzzy-mode)
  ;; (company-mode . company-box-mode) ;; why it doesn't work at compbox package def below?
  :config
  ;; (with-eval-after-load 'evil
  ;;   (evil-define-key 'insert 'company-active-map (kbd "TAB") #'company-indent-or-complete-common))
  ;; TODOOOO: its a mess!
  (with-eval-after-load 'general
    (general-def 'insert company-active-map "TAB" 'company-indent-or-complete-common)
    (general-def 'insert company-active-map "RET" 'company-complete-selection)
    (general-def company-active-map "RET" 'company-complete-selection)
    )
  (define-key company-active-map (kbd "RET") #'company-complete-selection)
  ;; (general-def 'insert company-mode-map [remap indent-for-tab-command] 'company-indent-or-complete-common)
  ;; dunno why it doesn't work simply in :config
  (add-hook 'company-mode-hook #'(lambda ()
                                   (define-key company-active-map (kbd "RET") #'company-complete-selection)
                                   ))

  )

(use-package company-fuzzy
  :ensure
  :after company
  :custom
  (company-fuzzy-sorting-backend 'flx)
  (company-fuzzy-reset-selection t)
  (company-fuzzy-prefix-on-top t)
  (company-fuzzy-show-annotation t)
  (company-fuzzy-trigger-symbols '("." "->" "<" "\"" "'" "@")))

(use-package company-prescient :ensure
  :disabled
  :after (prescient company)
  :hook (company-mode . company-prescient-mode))

(use-package company-quickhelp
  :ensure :demand :after company
  :hook (company-mode . company-quickhelp-mode))

(use-package company-posframe
  ;; also doesn't play well with company-box
  :disabled
  :ensure :after company
  :hook (company-mode . company-posframe-mode))

;; this one helps when using mixed-pitch e.g. in org
;; otherwise the completion box lines have different indents
(use-package company-box
  :ensure :demand :after company :diminish
  :config
  (add-hook 'company-mode-hook #'(lambda ()
                                   (run-with-idle-timer 1 nil #'company-box-mode)
                                   ))
  ;; :hook (company-mode . company-box-mode)
  )

(use-package company-emoji
  ;; problematic, performance issues
  :disabled
  :ensure :after company)

(use-package smart-tab
  :ensure
  :disabled ;; 'company-indent-or-complete-common is actually better: 
  :config (global-smart-tab-mode 1)
  :custom
  (smart-tab-user-provided-completion-function #'company-complete-common)
  (smart-tab-using-hippie-expand t))
#+end_src

** yasnippet

#+begin_src emacs-lisp
(use-package yasnippet
  :ensure
  :after evil
  :diminish (yas-minor-mode . "") ;; " Y"
  :config
  ;;(yas-reload-all)
  ;; default dir is ~/.emacs.d/snippets, others are somehow loaded from yasnippet-snippets
  ;; (yas-global-mode 1)
  ;;:bind ("<tab>" . yas-expand)
  :init
  (evil-define-key 'motion global-map (kbd "<leader>y") 'hydra-yas/body)
  :commands hydra-yas/body yas-global-mode
  :pretty-hydra
  (hydra-yas
   (:color blue :quit-key "q" :hint nil :title (with-faicon "code" "Yas" 1 -0.05))
   ("Modes"
    (("g" yas-global-mode "global")
     ("m" yas-minor-mode "minor")
     ("e" yas-activate-extra-mode "extra"))
    "Load/Visit"
    (("d" yas-load-directory "directory")
     ("f" yas-visit-snippet-file "file" :color blue)
     ("l" yas-describe-tables "list")
     ("a" yas-reload-all "all"))
    "Actions"
    (("i" yas-insert-snippet "insert")
     ("t" yas-tryout-snippet "tryout")
     ("n" yas-new-snippet "new"))))
  )

(use-package yasnippet-snippets
  :ensure
  :demand :after yasnippet)

(use-package ivy-yasnippet
  :ensure :demand :after yasnippet
  :pretty-hydra (hydra-yas ("Actions" (("i" ivy-yasnippet "insert")))))


;; very slow load
;;(use-package aws-snippets
;;  :after yasnippet)
#+end_src

** lsp

#+begin_src emacs-lisp
(use-package lsp-mode
  :ensure
  :pin melpa
  :after general
  :commands (lsp lsp-deferred hydra-lsp/body)
  :general (:states 'motion "<leader>l" 'hydra-lsp/body)
  :hook ((haskell-mode . lsp-deferred)
         (lsp-mode . company-mode)
         (lsp-mode . lsp-lens-mode)
         (lsp-mode . (lambda ()
                       (setq-local dimmer-mode nil) ;; disable global mode
                       (eldoc-mode -1)
                       )))
  ;; waits too long when typing
  ;;:config (add-hook 'lsp-mode-hook #'lsp-enable-which-key-integration)
  :custom
  ;; (lsp-keymap-prefix "C-l")
  (lsp-idle-delay 0.500)
  (lsp-progress-prefix "") ;; rendering issues with icon and tab-bar
  ;;(lsp-log-io nil)
  (lsp-completion-provider :none) ;; with ;capf it messes my carefully composed company-backends list
  (lsp-signature-auto-activate nil)
  ;; suspicious of lsp hangs, using highlight-symbol-mode for now
  (lsp-enable-symbol-highlighting nil)
  :init
  ;; WIP
  ;; (define-advice lsp--help-open-link (:after lsp-help-link-browse)
  ;;   "LSP opens 'file://' links locally (and fails with # suffixes in the URL). This advice opens URL externally."
  ;;   (message "buf=%s file=%s" (window-buffer) (buffer-file-name))
  ;;   ;; Uncomment the following lines to enable external browsing:
  ;;   ;; (browse-url-of-buffer)
  ;;   ;; (quit-window t)
  ;;   )
  :config
  (require 'company)
  ;; Uncomment following few lines if you would like to tune lsp-mode performance according to
  ;; https://emacs-lsp.github.io/lsp-mode/page/performance/
  ;;(setq gc-cons-threshold 100000000) ;; 100mb
  (setq read-process-output-max (* 1024 1024)) ;; 1mb
  (require 'lsp-protocol)
  ;; ain't have any space
  (diminish 'lsp-mode "") ;; " LSP"
  (diminish 'lsp-lens-mode " Lens")
  (general-define-key :keymaps 'lsp-mode-map [remap evil-goto-definition] 'lsp-find-definition)
  :pretty-hydra
  (hydra-lsp
   (:hint nil :color teal :quit-key "q" :exit t :title (with-faicon "rocket" "Lsp"))
   ("Find"
    (("D" lsp-find-declaration "declaration")
     ("d" lsp-find-definition "definition")
     ("R" lsp-find-references "references")
     ("i" lsp-find-implementation "implementation")
     ("gt" lsp-find-type-definition "type")
     ("f" lsp-ivy-workspace-symbol "symbol")
     ("F" lsp-ivy-global-workspace-symbol "global symbol")
     ("uf" lsp-ui-find-workspace-symbol "ui symbol")
     ("pd" lsp-ui-peek-find-definitions "peek def")
     ("pr" lsp-ui-peek-find-references "peek refs")
     ("pf" lsp-ui-peek-find-workspace-symbol "peek symb")
     ("pi" lsp-ui-peek-find-implementation "peek impl"))
    "Toggle"
    (("Td" lsp-ui-doc-mode "doc" :toggle t :exit nil)
     ("TS" lsp-ui-sideline-mode "sideline" :toggle t :exit nil)
     ("Ts" lsp-ui-sideline-toggle-symbols-info "side symb" :toggle lsp-ui-sideline-show-hover :exit nil)
     ("Tl" lsp-lens-mode "lens" :toggle t :exit nil)
     ("Ti" lsp-toggle-trace-io "trace-io" :toggle lsp-log-io :exit nil)
     ("Th" lsp-toggle-symbol-highlight "symb highlight" :toggle lsp-enable-symbol-highlighting :exit nil)
     ("Tf" lsp-toggle-on-type-formatting "format" :toggle lsp-enable-on-type-formatting :exit nil)
     ("TT" lsp-treemacs-sync-mode "treemacs sync" :toggle t :exit nil)
     ("TD" lsp-modeline-diagnostics-mode "diag line" :toggle t :exit nil)
     ("Tnf" lsp-signature-toggle-full-docs "sign docs full")
     ("Tna" lsp-signature-activate "sign activate help")
     ("Tns" lsp-toggle-signature-auto-activate "sign auto activate"))
    "Code"
    (("=f" lsp-format-buffer "format")
     ("=r" lsp-format-region "region")
     ("r" lsp-rename "rename")
     ("o" lsp-organize-imports "org imports")
     ("m" lsp-ui-imenu "imenu")
     ("x" lsp-execute-code-action "action")
     ("h" lsp-ui-doc-toggle "doc toggle")
     ;; ("H" lsp-ui-doc-glance "doc glance")
     ("H" lsp-describe-thing-at-point "describe")
     ("l" lsp-avy-lens "avy lens")
     ("gc" lsp-treemacs-call-hierarchy "call hierarchy")
     ("gt" lsp-treemacs-type-hierarchy "type hierarchy")
     ("ge" lsp-treemacs-errors-list "errors")
     ("gf" lsp-ui-flycheck-list "diagnostics")
     ("gs" lsp-treemacs-symbols "symbols")
     ("gi" lsp-treemacs-implementations "implementations")
     ("gr" lsp-treemacs-references "references")
     ("ga" xref-find-apropos "xref-apropos"))
    "Session"
    (("s?" lsp-describe-session "describe")
     ("ss" lsp "start")
     ("sd" lsp-disconnect "disconnect")
     ("sr" lsp-workspace-restart "restart")
     ("sq" lsp-workspace-shutdown "shutdown")
     ("sl" lsp-workspace-show-log "log")
     ("sfa" lsp-workspace-folders-add "folders +")
     ("sfo" lsp-workspace-folders-open "folder")
     ("sfr" lsp-workspace-folders-remove "folders -")
     ("sfb" lsp-workspace-blacklist-remove "blacklist -")))))

(use-package lsp-ui
  :ensure
  :pin melpa
  :custom
  (lsp-ui-doc-position 'at-point)
  (lsp-ui-doc-include-signature t)
  (lsp-ui-doc-alignment 'window)
  (lsp-ui-doc-use-childframe t)
  (lsp-ui-peek-always-show nil)
  (lsp-eldoc-enable-hover t)
  (lsp-eldoc-render-all t)
  (lsp-ui-doc-use-webkit nil) ;; buggy as of 2024
  (lsp-ui-flycheck-enable t)
  (lsp-ui-flycheck-list-position 'bottom)
  (lsp-ui-sideline-enable nil)
  ;; (lsp-ui-sideline-ignore-duplicate t)
  (lsp-ui-sideline-show-symbol nil)
  (lsp-ui-sideline-show-hover t)
  (lsp-ui-sideline-show-diagnostics t)
  (lsp-ui-sideline-show-code-actions nil)
  (lsp-ui-sideline-delay 0.8)
  (lsp-ui-sideline-diagnostic-max-lines 2)
  (lsp-ui-sideline-code-actions-prefix "* ") ;;  unfortunately such unicode icon changes text height a little, which is annoying 
  (lsp-ui-peek-enable nil)
  (lsp-ui-peek-list-width 60)
  (lsp-ui-peek-peek-height 25)
  (lsp-ui-imenu-enable t)
  (lsp-ui-imenu-kind-position 'top)
  (lsp-headerline-breadcrumb-icons-enable nil) ;; ugly
  (lsp-headerline-breadcrumb-enable-symbol-numbers nil)
  (lsp-headerline-breadcrumb-segments '(path-up-to-project file symbols)
                                      ;; '(symbols)
                                      )
  ;; (lsp-modeline-code-actions-segments '(count name)) ;; problem with formatting tab-bar-mode and light-bulb icon
  (lsp-modeline-code-actions-segments '(count icon))
  :custom-face
  (lsp-ui-sideline-symbol-info ((t (:family "Hack")))) ;; problems with slight text height change I don't want to debug
  (lsp-ui-sideline-code-action ((t (:family "Hack")))) ;; this font doesn't have this effect fortunately
  :bind (:map lsp-mode-map ("C-l m" . lsp-ui-imenu))
  :config
  :hook (lsp-mode . lsp-ui-mode)
  :commands (lsp-ui-mode)
  :after lsp-mode)

(use-package lsp-ivy
  :ensure
  :pin melpa
  :demand
  :after lsp-mode
  :commands lsp-ivy-workspace-symbol)

(use-package lsp-treemacs
  :ensure
  :pin melpa
  :demand
  :after lsp treemacs
  :config (lsp-treemacs-sync-mode 1)
  :custom (lsp-treemacs-error-list-severity 4)
  :general (evil-treemacs-state-map "M-k" 'quit-window-kill-buffer "M-j" 'quit-window)
  :commands (lsp-treemacs-errors-list lsp-treemacs-references))

(use-package dap-mode
  :ensure
  :after lsp-mode
  :config
  (dap-auto-configure-mode)
  (dap-ui-mode)
  (dap-ui-controls-mode 1)
  (when (executable-find "lldb-mi") ;; rust stuff
    (require 'dap-lldb)
    (require 'dap-gdb-lldb)
    ;; installs .extension/vscode
    (dap-gdb-lldb-setup)
    (dap-register-debug-template
     "Rust::LLDB Run Configuration"
     (list :type "lldb"
           :request "launch"
           :name "LLDB::Run"
	       :gdbpath "rust-lldb"
           ;; uncomment if lldb-mi is not in PATH
           ;; :lldbmipath "path/to/lldb-mi"
           )))
  :hook (dap-stopped . (lambda (arg) (call-interactively #'dap-hydra)))
  ;; performance-wise
  ;;(lsp-mode . dap-mode)
  ;;(lsp-mode . dap-ui-mode)
  )

(use-package company-lsp
  :ensure
  :disabled ;; lsp-capf is used?
  :after lsp-mode company
  :custom
  (company-lsp-cache-candidates t) ;; auto, t(always using a cache), or nil
  (company-lsp-async t)
  (company-lsp-enable-snippet t)
  (company-lsp-enable-recompletion t)
  :commands company-lsp)
#+end_src

** c++/c
#+begin_src emacs-lisp
(use-package ccls
  :ensure
  :config
  (setq ccls-executable "ccls")
  (setq lsp-prefer-flymake nil)
  (setq-default flycheck-disabled-checkers '(c/c++-clang c/c++-cppcheck c/c++-gcc))
  ;:hook ((c-mode c++-mode objc-mode) .
  ;       (lambda () (require 'ccls) (lsp))))
)
#+end_src

** scala

#+begin_src emacs-lisp
(use-package lsp-metals
  :ensure
  :after lsp
  :config
  (with-eval-after-load 'treemacs 
    (setq lsp-metals-treeview-show-when-views-received t)
    (lsp-metals-treeview-enable t)
    (lsp-metals-treeview-theme 'Metals-dark))
  (major-mode-hydra-define
    scala-mode
    (:hint nil :color teal :quit-key "q" :exit t :title (with-alltheicon "scala" "Scala"))
    ("Metals"
     (("mb" lsp-metals-build-import "build import")
      ("ms" lsp-metals-sources-scan "sources rescan")
      ("mr" lsp-metals-build-connect "bloop reconnect")))))

(use-package scala-mode
  :ensure
  :mode "\\.s\\(cala\\|bt\\|c\\)$"
  :interpreter ("scala" . scala-mode)
  :config
  (require 'smartparens)
  (require 'smartparens-scala)
  (defun sp-restrict-c (sym)
    "Smartparens restriction on `SYM' for C-derived parenthesis."
    (sp-restrict-to-pairs-interactive "{([" sym))
  (bind-key "C-S-<tab>" 'dabbrev-expand scala-mode-map)
  (bind-key "s-<delete>" (sp-restrict-c 'sp-kill-sexp) scala-mode-map)
  (bind-key "s-<backspace>" (sp-restrict-c 'sp-backward-kill-sexp) scala-mode-map)
  (bind-key "s-<home>" (sp-restrict-c 'sp-beginning-of-sexp) scala-mode-map)
  (bind-key "s-<end>" (sp-restrict-c 'sp-end-of-sexp) scala-mode-map)
  :hook
  (scala-mode
   . (lambda()
       ;;indentation and asterisk-insertion within multi-line comments.
       ;; An alternative is the  'reindent-then-newline-and-indent' command.
       (local-set-key (kbd "RET") '(lambda ()
                                     (interactive)
                                     (newline-and-indent)
                                     (scala-indent:insert-asterisk-on-multiline-comment)))
       (local-set-key (kbd "<backtab>") 'scala-indent:indent-with-reluctant-strategy)
       ;; clean-up whitespace at save
       (make-local-variable 'before-save-hook)
       (add-hook 'before-save-hook 'whitespace-cleanup)
       (setq comment-start "/* "
             comment-end " */"
             comment-style 'multi-line
             comment-empty-lines t)
       (smartparens-mode)
       (scala-mode:goto-start-of-code))))

(use-package play-routes-mode
  :ensure
  ;;:disabled
  :hook (play-routes-mode . (lambda ()
                              (font-lock-add-keywords
                               nil '(("\\<\\(FIXME\\|TODO\\|fixme\\|todo\\):" 1 font-lock-warning-face t))))))

(use-package sbt-mode
  :ensure
  :after evil
  ;; :init (evil-define-key 'motion global-map (kbd "<leader>S") 'sbt-hydra)
                                        ;:config
  ;; sbt-supershell kills sbt-mode:  https://github.com/hvesalai/emacs-sbt-mode/issues/152
                                        ; (setq sbt:program-options '("-Dsbt.supershell=false"))
  )
#+end_src

** python

#+begin_src emacs-lisp
(use-package python
  :mode ("\\.py$" . python-ts-mode)
  :config
  (setq
   ;; python-shell-interpreter "jupyter"
   ;; python-shell-interpreter-args "console --simple-prompt"
   python-shell-interpreter "ipython"
   python-shell-interpreter-args "--profile default -i"
   ;; python-shell-interpreter-args "--simple-prompt --profile default"
   python-shell-prompt-detect-failure-warning nil)
  :hook (python-base-mode . elpy-mode)
  )

;; pyls - palantir (old)
;; pylsp - newer fork of ms by spyder-ide
;; pyright - newer ms server focused on type-checking

(use-package lsp-pylsp
  :custom
  (lsp-pylsp-plugins-ruff-enabled t)
  ;; (lsp-pylsp-plugins-mypy-enabled t)
  ;; (lsp-pylsp-plugins-mypy-report-progress t)
  ;; (lsp-pylsp-plugins-mypy-dmypy t)
  ;; (lsp-pylsp-plugins-mypy-live-mode nil)
  ;; (lsp-pylsp-plugins-isort-enabled t)
  ;; (lsp-pylsp-plugins-black-enabled t)
  ;; (lsp-pylsp-plugins-rope-completion-enabled t)
  ;; (lsp-pylsp-plugins-rope-autoimport-enabled t)
  (lsp-pylsp-rename-backend 'rope)
  )

(use-package ein :ensure)

(setq native-comp-jit-compilation-deny-list
      '("jupyter.*\\.el" "zmq.*\\.el"))

(use-package zmq :ensure)

(use-package jupyter :ensure
  :custom
  (jupyter-repl-echo-eval-p t)
  (jupyter-executable "/usr/bin/jupyter")
  :config
  (defun jupyter-server-repl-in-current-dir (directory)
    (interactive "DDirectory: ")
    (let ((default-directory directory))
      (call-interactively #'jupyter-run-server-repl)
      ;; (jupyter-repl-associate-buffer jupyter-current-client)
      ))
  (defun jupyter-api-start-kernel-in-directory (client &optional name path)
    (apply #'jupyter-api/kernels client "POST"
           (when name (list :name name :path path))))
  (defun jupyter-server-launch-kernel-with-path (server directory)
    (interactive 
     (list 
      (jupyter-current-server current-prefix-arg)
      (read-directory-name "Select directory: " default-directory)))
    (let* ((specs (jupyter-kernelspecs server))
           (spec (jupyter-completing-read-kernelspec specs)))
      (jupyter-api-start-kernel-in-directory server (jupyter-kernelspec-name spec) directory)))

  )

(use-package snakemake-mode :ensure)

;; alternative
;;(use-package lsp-pyright :ensure)

;; python flycheck ruff config some ideas
;;https://github.com/martibosch/snakemacs/blob/code-cells-py/main.el

(use-package code-cells
  :ensure
  :hook
  (python-ts-mode . code-cells-mode-maybe)
  (python-mode . code-cells-mode-maybe)
  :config
  ;; (setq code-cells-convert-ipynb-style
  ;;       '(("/home/twist/micromamba/envs/geo-ml/bin/jupytext"
  ;;          "--to" "ipynb")
  ;;         ("/home/twist/micromamba/envs/geo-ml/bin/jupytext"
  ;;          "--to" "auto:percent")
  ;;         code-cells--guess-mode
  ;;         code-cells-convert-ipynb-hook))
  (defun jupytext-sync ()
    "Sync py file to ipynb."
    (interactive)
    (call-process "jupytext" nil 0 nil "--sync" (buffer-file-truename)))
  (let ((map code-cells-mode-map))
    (define-key map (kbd "M-p") 'code-cells-backward-cell)
    (define-key map (kbd "M-n") 'code-cells-forward-cell)
    (define-key map (kbd "C-c C-c") 'code-cells-eval)
    ;; Overriding other minor mode bindings requires some insistence...
    (define-key map [remap jupyter-eval-line-or-region] 'code-cells-eval))
  (let ((map code-cells-mode-map))
    (define-key map [remap evil-search-next] (code-cells-speed-key 'code-cells-forward-cell))  ;; n
    (define-key map [remap evil-paste-after] (code-cells-speed-key 'code-cells-backward-cell)) ;; p
    ;; (define-key map [remap evil-backward-word-begin] (code-cells-speed-key 'code-cells-eval-above)) ;; b
    ;; (define-key map [remap evil-forward-word-end] (code-cells-speed-key 'code-cells-eval)) ;; e
    (define-key map [remap evil-jump-forward] (code-cells-speed-key 'outline-cycle)))      ;; TAB
  )

(use-package elpy
  :ensure t
  :defer t
  :after company general
  :init
  ;; hard way
  ;; (require 'pyenv-mode)
  ;; (pyenv-mode-set "3.12.8")
  ;; (setq elpy-rpc-python-command (concat (getenv "HOME") "/.pyenv/shims/python"))
  (elpy-enable)
  (advice-add 'python-base-mode :before 'elpy-enable)
  :config
  ;;(setq elpy-modules (delq 'elpy-module-flymake elpy-modules))
  (setq elpy-modules '(elpy-module-company
                       ;; elpy-module-eldoc
                       ;;elpy-module-flymake
                       elpy-module-folding
                       elpy-module-pyvenv
                       ;; elpy-module-highlight-indentation 
                       elpy-module-yasnippet
                       ;; elpy-module-django
                       elpy-module-autodoc
                       elpy-module-sane-defaults))
  (setq elpy-formatter 'black)
  ;; (add-hook 'elpy-mode-hook 'flycheck-mode)
  ;; (add-hook 'elpy-mode-hook 'py-autopep8-enable-on-save)
  ;; adding '# %%' pattern
  (setq elpy-test-runner 'elpy-test-pytest-runner)
  (add-hook 'elpy-mode-hook
            #'(lambda ()
                ;; disable annoying mouse selection toggling,
                ;; no idea why this happens with python/elpy buffers
                (general-def evil-motion-state-map "<down-mouse-1>" nil)
                ))
  ;; (add-hook 'elpy-mode-hook #'(lambda ()
  ;;                               (company-mode -1)
  ;;                               (company-fuzzy-mode -1)
  ;;                               (add-to-list 'company-backends 'elpy-company-backend)
  ;;                               (company-fuzzy-backend-add 'elpy-company-backend)
  ;;                               (company-mode 1)
  ;;                               ;; currently compy-fuzzy doesn't work with elpy-company-backend
  ;;                               (company-fuzzy-mode -1)
  ;;                               ))
  (setq elpy-shell-cell-boundary-regexp
        "^\\(?:##.*\\|# %%\\|#\\s-*<.+>\\|#\\s-*\\(?:In\\|Out\\)\\[.*\\]:\\)\\s-*$")
  (setq elpy-shell-codecell-beginning-regexp
        "^\\(?:##.*\\|# %%\\|#\\s-*<codecell>\\|#\\s-*In\\[.*\\]:\\)\\s-*$")
  (define-key elpy-mode-map (kbd "C-c C-c") 'elpy-shell-send-codecell-and-step)
  (add-to-list 'python-shell-completion-native-disabled-interpreters "jupyter")
  (defun elpy-goto-definition-or-rgrep ()
    "Go to the definition of the symbol at point, if found. Otherwise, run `elpy-rgrep-symbol'."
    (interactive)
    (condition-case nil (elpy-goto-definition)
      (error (elpy-rgrep-symbol
              (concat "\\(def\\|class\\)\s" (thing-at-point 'symbol) "(")))))
  (define-key elpy-mode-map (kbd "M-.") 'elpy-goto-definition-or-rgrep)
  ;; to have proper code highlight in the repl
  (advice-add 'elpy-shell--insert-and-font-lock
              :around (lambda (f string face &optional no-font-lock)
                        (if (not (eq face 'comint-highlight-input))
                            (funcall f string face no-font-lock)
                          (funcall f string face t)
                          (python-shell-font-lock-post-command-hook))))
  (advice-add 'comint-send-input
              :around (lambda (f &rest args)
                        (if (eq major-mode 'inferior-python-mode)
                            (cl-letf ((g (symbol-function 'add-text-properties))
                                      ((symbol-function 'add-text-properties)
                                       (lambda (start end properties &optional object)
                                         (unless (eq (nth 3 properties) 'comint-highlight-input)
                                           (funcall g start end properties object)))))
                              (apply f args))
                          (apply f args)))
              )
  (define-fringe-bitmap 'elpy-folding-fringe-marker
    (vector
     #b0000000000000000
     #b0000000000000000
     #b0000000000000000
     #b0000000000000000
     #b1111000000001111
     #b1111000000001111
     #b1111110000111111
     #b1111110000111111
     #b0011111111111100
     #b0011111111111100
     #b0000111111110000
     #b0000111111110000
     #b0000001111000000
     #b0000001111000000
     #b0000000000000000
     #b0000000000000000
     ) 16 16 'center)
  (define-fringe-bitmap 'elpy-folding-fringe-foldable-marker
    (vector
     #b0000110000000000
     #b0000110000000000
     #b0000001100000000
     #b0000001100000000
     #b0000000011000000
     #b0000000011000000
     #b0000000000110000
     #b0000000000110000
     #b0000000000110000
     #b0000000000110000
     #b0000000011000000
     #b0000000011000000
     #b0000001100000000
     #b0000001100000000
     #b0000110000000000
     #b0000110000000000
     ) 16 16 'center)
  )

(use-package py-autopep8 :ensure)

(use-package blacken :ensure
  ;; :hook (python-base-mode . blacken-mode)
  :custom
  (blacken-target-version "py312")
  (blacken-line-length 100))

(use-package isortify :ensure
  ;; :hook (python-base-mode . isortify-mode)
  )

(use-package conda
  :ensure
  :disabled
  :config
  (conda-env-initialize-eshell)
  (conda-env-initialize-interactive-shells)
  :custom ((conda-anaconda-home (expand-file-name "/opt/miniconda3/"))
           (conda-env-home-directory (expand-file-name "/opt/miniconda3/"))))

(use-package micromamba :ensure :disabled)

(use-package auto-virtualenv
  :ensure
  :config (add-hook 'python-mode-hook 'auto-virtualenv-set-virtualenv))

(use-package pyenv-mode :ensure
  :demand :after python)

(use-package pyvenv
  :demand
  :after python
  :ensure
  :init
  (advice-add 'python-base-mode :before 'pyvenv-mode)
  :config
  ;; (pyvenv-mode)
  (pyvenv-tracking-mode))

;; TOTRY: https://github.com/erickgnavar/flymake-ruff
#+end_src

** indent
#+begin_src emacs-lisp
(use-package indent-bars
  :ensure t
  :config
  (require 'indent-bars-ts) ;; not needed with straight
  :custom
  (indent-bars-treesit-support t)
  (indent-bars-treesit-ignore-blank-lines-types '("module"))
  ;; Add other languages as needed
  (indent-bars-treesit-scope '((python function_definition class_definition for_statement
	                                   if_statement with_statement while_statement)))
  ;; Note: wrap may not be needed if no-descend-list is enough
  ;;(indent-bars-treesit-wrap '((python argument_list parameters ; for python, as an example
  ;;				      list list_comprehension
  ;;				      dictionary dictionary_comprehension
  ;;				      parenthesized_expression subscript)))
  :hook ((python-base-mode yaml-mode) . indent-bars-mode))
#+end_src

** java

#+begin_src emacs-lisp
;; java config taken from https://blog.jmibanez.com/2019/03/31/emacs-as-java-ide-revisited.html
(use-package lsp-java
  :disabled
  :ensure
  :pin melpa
  :init
  (defun java-mode-config ()
    (toggle-truncate-lines 1)
    (setq-local tab-width 4)
    (setq-local c-basic-offset 4))
  :config
  ;; Enable dap-java
  (require 'dap-java)
  (setq lombok-jar (expand-file-name "/usr/lib/lombok-common/lombok.jar"))
  ;;(setq my/java-format-settings-file (expand-file-name "~/projects/defaultFormatterProfile.xml"))
  (setq lsp-java-vmargs (list "-noverify"
                              "-Xmx2G"
                              "-XX:+UseG1GC"
                              "-XX:+UseStringDeduplication"
                              (concat "-javaagent:" lombok-jar)
                              (concat "-Xbootclasspath/a:" lombok-jar))
        lsp-java-import-order '["" "java" "javax" "#"]
        ;; Don't organize imports on save
        lsp-java-save-action-organize-imports nil
        ;; Formatter profile
        lsp-java-format-settings-url "https://raw.githubusercontent.com/google/styleguide/gh-pages/eclipse-java-google-style.xml")
  :hook (java-mode . java-mode-config)
  :after (lsp-mode dap-mode))
#+end_src

** sql
*** ejc

#+begin_src emacs-lisp
(use-package ejc-sql
  :ensure
  :disabled
  ;;:after company-quickhelp - this makes it loading realy after explicit quickhelp load
  :config
  ;;(require 'ejc-sql)
  ;;(require 'ejc-autocomplete)
  (require 'ejc-company)
  (push 'ejc-company-backend company-backends)
  (add-hook 'ejc-sql-minor-mode-hook
            (lambda ()
              ;;(auto-complete-mode t)
              ;;(ejc-ac-setup)
              (ejc-eldoc-setup)
              (company-mode t)))
  (add-hook 'ejc-sql-connected-hook
            (lambda ()
              (ejc-set-fetch-size 200)
              (ejc-set-max-rows 200)
                                        ;(ejc-set-show-too-many-rows-message t)
              (ejc-set-column-width-limit 100)
                                        ;(ejc-set-use-unicode t)
              ))
                                        ;(setq ejc-result-table-impl 'ejc-result-mode)
  (setq ejc-result-table-impl 'orgtbl-mode)
  ;; this will change begin_example to lines starting with :
  (setq org-babel-min-lines-for-block-output 1000)
  ;; sets timeout for long queries, otherwise nrepl will fail (default is 10)
  (setq nrepl-sync-request-timeout 600)
  (global-set-key (kbd "C-c eb") 'ejc-get-temp-editor-buffer)
  (require 'company-quickhelp)
  (company-quickhelp-mode)
  (ejc-create-connection
   "presto"
   :subprotocol "presto"
   :dependencies [[com.facebook.presto/presto-jdbc "0.232"]]
   ;;:classpath (concat "~/.m2/repository/com/facebook/presto/presto-jdbc/0.232/" "presto-jdbc-0.232.jar")
   :connection-uri (concat
                    "jdbc:presto://presto-db.thetimmedia.site:8889/hive/default?"
                    "user=hadoop"))
  (ejc-create-connection
   "conf-db"
   :subprotocol "mysql"
   ;;:dependencies [[mysql/mysql-connector-java "6.0.5"]]

   :dependencies [[org.mariadb.jdbc/mariadb-java-client "2.6.2"]]
   ;;:classname "com.mysql.cj.jdbc.Driver"
   :classname "org.mariadb.jdbc.Driver"
   :connection-uri "jdbc:mariadb://conf-db.site:3306/data"
   :user "app"
   :password (funcall (plist-get (nth 0 (auth-source-search :host "conf-db.site" :require '(:user :secret))) :secret)))
  (ejc-create-connection
   "content-db"
   :subprotocol "mysql"
   :dependencies [[org.mariadb.jdbc/mariadb-java-client "2.6.2"]]
   :classname "org.mariadb.jdbc.Driver"
   :connection-uri "jdbc:mariadb://content-db.site:3306/data"
   :user "admin"
   :password (funcall (plist-get (nth 0 (auth-source-search :host "content-db.site" :require '(:user :secret))) :secret)))
  (ejc-create-connection
   "reporting-db"
   :subprotocol "postgresql"
   :classname "org.postgresql.Driver"
   :classpath "~/.m2/repository/postgresql/postgresql/9.3.1102.jdbc41/postgresql-9.3-1102.jdbc41.jar"
   :connection-uri "jdbc:postgresql://reporting-db.site:3306/postgres"
   :user "postgres"
   :password (funcall (plist-get (nth 0 (auth-source-search :host "reporting-db.site" :require '(:user :secret))) :secret)))
  (ejc-create-connection
   "redshift"
   :subprotocol "postgres"
   ;;:dependencies [[com.amazon.redshift/redshift-jdbc42 "1.2.37.1061"]]
   :classpath "/home/twist/.m2/repository/com/amazon/redshift/redshift-jdbc42/jar/redshift-jdbc42-jar.1.2.37.1061"
   :classname "com.amazon.redshift.jdbc42.Driver"
   :connection-uri "jdbc:redshift://redshift-db.site:5439/dev"
   :user "adminelad"
   :password (funcall (plist-get (nth 0 (auth-source-search :host "redshift-db.site" :require '(:user :secret))) :secret)))
  (ejc-create-connection
   "hive"
   :subprotocol "hive"
   ;;:dependencies [[org.apache.hive/hive-jdbc "2.3.6"]]
   ;;:classpath "/home/twist/.m2/repository/org/apache/hive/hive-jdbc/2.3.6/hive-jdbc-2.3.6.jar"
   ;;:classname "org.apache.hive.jdbc.HiveDriver"
   ;;in fact this path is not valid maven path, but for valid clomacs fails as it tries to resolve artifact in some remote inaccessible repo
   :classpath "/home/twist/.m2/repository/org/amazon/hive/hive-jdbc41-amazon/jar/hive-jdbc41-amazon-jar.2.6.2"
   :classname "com.amazon.hive.jdbc41.HS2Driver"
   :connection-uri "jdbc:hive2://presto-db.site:10000/default"
   :user "hadoop")
  (ejc-create-connection
   "spark-test"
   :subprotocol "spark-sql"
   :classpath ["/home/twist/.m2/repository/org/amazon/spark/spark-jdbc41-amazon/alljars/hive-jdbc-1.2.1-spark2-amzn-1.jar"
               "/home/twist/.m2/repository/org/amazon/spark/spark-jdbc41-amazon/alljars/libthrift-0.9.3.jar"
               "/home/twist/.m2/repository/org/amazon/spark/spark-jdbc41-amazon/alljars/hadoop-common-2.8.5-amzn-5.jar"
               "/home/twist/.m2/repository/org/amazon/spark/spark-jdbc41-amazon/alljars/hive-metastore-1.2.1-spark2-amzn-1.jar"
               "/home/twist/.m2/repository/org/amazon/spark/spark-jdbc41-amazon/alljars/hive-exec-1.2.1-spark2-amzn-1.jar"
               "/home/twist/.m2/repository/org/amazon/spark/spark-jdbc41-amazon/alljars/spark-hive-thriftserver_2.11-2.4.4.jar"]
   :classname "org.apache.hive.jdbc.HiveDriver"
   :connection-uri "jdbc:hive2://spark2.site:10001"
   :user "hadoop")
  )
#+end_src

*** sql.el & tools

#+begin_src emacs-lisp
(use-package sql-presto
  :ensure
  :disabled
  ;:custom
  ;(sql-presto-options ("--output-format" "CSV_HEADER" ))
  )

(use-package sqlformat
  :ensure
  :commands (sqlformat sqlformat-buffer sqlformat-region)
  ;:hook (sql-mode . sqlformat-on-save-mode)
  ;:init
  ;(setq sqlformat-command 'pgformatter
  ;      sqlformat-args '("-s2" "-g" "-u1"))
  )

(use-package sql
  :init
  (defun my-sql-login-hook ()
    "Custom SQL log-in behaviours. See `sql-login-hook'."
    (when (eq sql-product 'postgres)
      (let ((proc (get-buffer-process (current-buffer))))
        ;; Output each query before executing it. (n.b. this also avoids
        ;; the psql prompt breaking the alignment of query results.)
        (comint-send-string proc "\\set ECHO queries\n")
        (comint-send-string proc "\\pset null '<null>'\n"))))
  :hook
  ;;(sql-mode . company-mode)
  (sql-interactive-mode . (lambda () (toggle-truncate-lines 1)))
  (sql-login . my-sql-login-hook)
  :custom
  (comint-move-point-for-output 'this)
  (comint-scroll-to-bottom-on-input 'all)
  (sql-connection-alist
   '((mysql-local
      (sql-product 'mysql)
      (sql-server "127.0.0.1")
      (sql-user "root")
      (sql-password "root")
      (sql-database "db")
      (sql-port 3306))
     (postgres-local
      (sql-product 'postgres)
      (sql-server "localhost")
      (sql-port 5432)
      (sql-user "postgres")
      (sql-password "postgres")
      (sql-database "postgres"))
     (sqlite
      (sql-product 'sqlite)
      (sql-database "e:\\Documents\\work\\sql\\tmp\\tmp.db"))))
  :config

  (add-to-list 'auto-mode-alist '("\\.hql$" . sql-mode))

  (add-to-list 'display-buffer-alist '("*sql"
                                       (display-buffer-reuse-window display-buffer-in-side-window)
                                       (side . right)
                                       (slot . -1)
                                       (window-width . 0.5)
                                       (reusable-frames . nil)))
  ;; this makes connection list in .dir-locals.el safe
  (put 'sql-connection-alist 'safe-local-variable #'listp)
  ;; trying to friend sql and pass
  ;;(setq sql-postgres-options "-w")
  ;;(setq sql-password-search-wallet-function #'sql-pass-search-wallet)
  ;;(defun sql-pass-search-wallet (wallet product user server database port)
  ;;          (auth-source-pass-get 'secret wallet))
  ;; it's so annoying
  (evil-collection-define-key '(insert replace) 'sql-interactive-mode (kbd "C-a") 'beginning-of-line)
  )

#+end_src

*** ob-sql-mode
#+begin_src emacs-lisp
  (use-package ob-sql-mode
  :ensure
    :after (org ob sql))
#+end_src

*** lsp-sqls

#+begin_src emacs-lisp
(use-package lsp-sqls
  :after lsp
  :custom
  (lsp-sqls-connections
        '(((driver . "mysql") (dataSourceName . "local:local@tcp(localhost:3306)/testdb"))
          ((driver . "postgresql") (dataSourceName . "host=127.0.0.1 port=5433 user=postgres dbname=postgres sslmode=disable"))))
  :config
  ;; this makes connection list in .dir-locals.el safe
  (put 'lsp-sqls-connections 'safe-local-variable #'listp)
  :pretty-hydra
  (hydra-lsp (
  "SQL"
  (("Sl" lsp-sql-show-schemas "show schemas")
   ("Sq" lsp-sql-execute-query "exec query")
   ("Ss" lsp-sql-execute-paragraph "exec paragraph")
   ("Sd" lsp-sql-show-databases "show databases")
   ("SD" lsp-sql-switch-database "switch database")
   ("Sc" lsp-sql-show-connections "show conns")
   ("SC" lsp-sql-switch-connection "switch conn")))))
#+end_src

** haskell

#+begin_src emacs-lisp
(use-package haskell-mode
  :ensure
  :custom
  (haskell-process-type 'stack-ghci)
  (haskell-process-log t)
  :hook
  (haskell-mode . haskell-indent-mode)
  :general ('insert 'haskell-indent-map "<backtab>" 'haskell-indent-cycle)
  :config
  ;; (diminish 'interactive-haskell-mode "IHs")
  (major-mode-hydra-define
    haskell-mode
    (:hint nil :color teal :quit-key "q" :exit t :title (with-alltheicon "haskell" "Haskell"))
    ("REPL"
     (("i" haskell-interactive-bring "repl")
      ("f" run-haskell "inferior")
      )))
  ;; Experiment: copy of haskell-interactive-mode-handle-h
  (defun haskell-interactive-mode-handle-r ()
    "Handle ^M in output."
    (let ((bound (point-min))
          (inhibit-read-only t))
      (save-excursion
        (while (search-backward "\r" bound t 1)
          (save-excursion
            (forward-char)
            (let ((end (point)))
              (if (search-backward-regexp "[^\r]" bound t 1)
                  (forward-char)
                (goto-char (point-min)))
              (let ((start (point)))
                (delete-region (max (- (point) (- end start))
                                    (point-min))
                               end))))))))
  ;; (advice-add 'haskell-interactive-mode-handle-h :after #'haskell-interactive-mode-handle-r)
  )

(unless (eq system-type 'windows-nt)
  (use-package lsp-haskell :ensure :after lsp))

(use-package flycheck-haskell :ensure)
#+end_src

** treesit
#+begin_src emacs-lisp
(use-package treesit
  :config
  (setq treesit-language-source-alist
        '((bash "https://github.com/tree-sitter/tree-sitter-bash")
          (cmake "https://github.com/uyha/tree-sitter-cmake")
          (css "https://github.com/tree-sitter/tree-sitter-css")
          (elisp "https://github.com/Wilfred/tree-sitter-elisp")
          (go "https://github.com/tree-sitter/tree-sitter-go")
          (rust "https://github.com/tree-sitter/tree-sitter-rust")
          (html "https://github.com/tree-sitter/tree-sitter-html")
          (javascript "https://github.com/tree-sitter/tree-sitter-javascript" "master" "src")
          (json "https://github.com/tree-sitter/tree-sitter-json")
          (make "https://github.com/alemuller/tree-sitter-make")
          (markdown "https://github.com/ikatyang/tree-sitter-markdown")
          (python "https://github.com/tree-sitter/tree-sitter-python")
          (toml "https://github.com/tree-sitter/tree-sitter-toml")
          (tsx "https://github.com/tree-sitter/tree-sitter-typescript" "master" "tsx/src")
          (typescript "https://github.com/tree-sitter/tree-sitter-typescript" "master" "typescript/src")
          (yaml "https://github.com/ikatyang/tree-sitter-yaml")))
  )
#+end_src

** go
:PROPERTIES:
:ID:       1f96d3c5-3547-417f-bd76-714a7ae59a2c
:END:
#+begin_src emacs-lisp
;;yay -S go ;; go,gofmt
;;go install github.com/rogpeppe/godef@latest
;;go install golang.org/x/tools/gopls@latest
;;go install golang.org/x/tools/cmd/goimports@latest
;; alternatively can add:
;;.profile
;;export GOPATH="$(go env GOPATH)"
;;export PATH="${PATH}:${GOPATH}/bin"
(use-package go-mode
  :ensure
  :disabled
  :ensure-system-package
  (go
   (gofmt . go)
   (godef . "go install github.com/rogpeppe/godef@latest")
   (gopls . "go install golang.org/x/tools/gopls@latest")
   (goimport . "go install golang.org/x/tools/cmd/goimports@latest"))
  :config
  (add-to-list 'exec-path (concat (getenv "HOME") "/go/bin")))

;;go install golang.org/x/tools/cmd/guru@latest
(use-package go-guru
  :ensure
  :disabled
  :ensure-system-package
  (guru . "go install golang.org/x/tools/cmd/guru@latest")
  :config
  (add-hook 'go-mode-hook #'go-guru-hl-identifier-mode)
  )

#+end_src

** mmm
#+begin_src emacs-lisp
(use-package mmm-mode :ensure
  :config
  (setq mmm-global-mode 'maybe)
  (mmm-add-classes
   '((python-sql
      :submode sql-mode
      :front "\"\"\"[:space:]]*\\(SELECT\\|INSERT\\|UPDATE\\|DELETE\\|WITH\\)"
      :back "\"\"\"")))
  (mmm-add-mode-ext-class 'python-mode nil 'python-sql))
#+end_src
** other

#+begin_src emacs-lisp
(use-package json
  :ensure
  :config
  (add-to-list 'auto-mode-alist '("\\.avsc$" . json-mode))
  :custom (json-reformat:indent-width 2))

(use-package csv-mode :ensure)

(use-package yaml-mode
  :ensure
  :bind (:map yaml-mode-map ("C-m" . newline-and-indent)))

(use-package htmlize :ensure)

;(require 'ob-clojure)

(use-package cider
  :disabled
  :ensure
  :custom (org-babel-clojure-backend 'cider))

;(use-package awscli-capf
;  :commands (awscli-add-to-capf)
;  :hook (shell-mode . awscli-add-to-capf))

(use-package electric-operator :ensure)

(use-package gradle-mode :ensure)

(use-package groovy-mode :ensure)

;; a couple of interactive commands
(use-package know-your-http-well :ensure)

(use-package restclient :ensure)

;; very nice
;; (use-package color-identifiers-mode :ensure
;;   :diminish ;; " #id"
;;   :pretty-hydra (toggle-hydra ("Prog" (("I" color-identifiers-mode "color identifiers" :toggle t))))
;;   :hook (prog-mode . color-identifiers-mode-maybe)) ; omit annoying echo - use 'maybe' function here

(use-package nix-mode :ensure)

(use-package kotlin-mode :ensure)

(use-package flycheck-kotlin :ensure
  ;; :if (executable-find "yay") :ensure-system-package "yay -S --noconfirm ktlint"
  :demand :after kotlin-mode
  :config (flycheck-kotlin-setup))

(use-package kotlin-ts-mode :ensure
  :unless (eq system-type 'windows-nt))
;; :if (executable-find "yay") :ensure-system-package "yay -S tree-sitter-kotlin-git"

(use-package terraform-mode :ensure)

(use-package apache-mode :ensure)

(use-package ansible :ensure)

(use-package graphql-ts-mode :ensure)

(use-package devicetree-ts-mode :ensure
  :demand
  :mode (("\\.keymap$" . devicetree-ts-mode)
         ("\\.overlay$" . devicetree-ts-mode)
         ("\\.dts$" . devicetree-ts-mode)
         ("\\.dtsi$" . devicetree-ts-mode))
  :init
  (with-eval-after-load 'treesit
       (add-to-list 'treesit-language-source-alist
   		 '(devicetree "https://github.com/joelspadin/tree-sitter-devicetree"))))

(use-package rasi-mode :ensure)

(use-package ejson-mode :ensure)

(use-package ess :ensure)

(use-package tree-sitter-ess-r :ensure)

(use-package polymode :ensure)

(use-package poly-R :ensure)

;; experimenting
(use-package poly-erb :ensure
  :config
  (defvar poly-yaml-root-polymode
    (pm-polymode :name "yaml-root" :hostmode 'poly-yaml-hostmode) "yaml root polymode.")
  (define-polymode poly-yaml+erb-mode poly-yaml-root-polymode :innermodes '(poly-erb-innermode))
  )

(use-package just-mode :ensure)
#+end_src

** web
#+begin_src emacs-lisp
(use-package add-node-modules-path :ensure)

(use-package prettier-js :ensure)

(use-package typescript-mode :ensure)

(use-package php-mode :ensure)

(use-package js :ensure
  :custom (js-indent-level 2))

(use-package tide :ensure :disabled)

(use-package emmet-mode
  :ensure :diminish " EM"
  :hook
  (sgml-mode . emmet-mode) ;; Auto-start on any markup modes
  (html-mode . emmet-mode)
  (css-mode . emmet-mode))

(use-package js2-mode
  :ensure
  :config
  (add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
  (add-to-list 'auto-mode-alist '("\\.jsx?\\'" . js2-jsx-mode))
  (add-to-list 'interpreter-mode-alist '("node" . js2-jsx-mode))
  )

(use-package web-mode
  :ensure
  ;;:mode "\\.jsx?$\\|\\.html?$"
  :after flycheck
  :config
  ;;disable default checker
  (setq-default flycheck-disabled-checkers
                (append flycheck-disabled-checkers
                        '(javascript-jshint json-jsonlist)))
  ;; Enable eslint checker for web-mode
  (flycheck-add-mode 'javascript-eslint 'web-mode)
  ;; Enable flycheck globally
  (add-hook 'after-init-hook #'global-flycheck-mode)
  ;; for eslint and other stuff too
  (add-hook 'web-mode-hook 'add-node-modules-path)
  (add-hook 'web-mode-hook 'emmet-mode)
  ;; Using a local eslint from node_modules
  (add-hook 'flycheck-mode-hook 'add-node-modules-path)
  :custom
  (web-mode-code-indent-offset 2)
  (web-mode-content-types-alist '(("jsx" . "\\.js[x]?\\'")))
  (web-mode-markup-indent-offset 2)
  )
#+end_src

** mobile
#+begin_src emacs-lisp
;; Assuming usage with dart-mode
(use-package dart-mode
  :ensure
  :hook (dart-mode . flutter-test-mode)
  :custom
  (dart-sdk-path "/opt/flutter/bin/cache/dark-sdk/"
   dart-format-on-save t))

(use-package flutter
  :ensure
  :after dart-mode
  :bind (:map dart-mode-map
              ("C-M-x" . #'flutter-run-or-hot-reload))
  :custom
  (flutter-sdk-path "/opt/flutter/"))

(use-package hover
  :ensure
  :after dart-mode
  :bind (:map hover-minor-mode-map
              ("C-M-z" . #'hover-run-or-hot-reload)
              ("C-M-x" . #'hover-run-or-hot-restart)
              ("C-M-p" . #'hover-take-screenshot))
  :init
  (setq ;;hover-flutter-sdk-path "/opt/flutter" ; remove if `flutter` is already in $PATH
        ;;hover-command-path (concat (getenv "GOPATH") "/bin/hover") ; remove if `hover` is already in $PATH
        hover-hot-reload-on-save t
        hover-screenshot-path (concat (getenv "HOME") "/screenshots")
        hover-screenshot-prefix "hover-screenshot-"
        hover-observatory-uri "http://localhost:50300"
        hover-clear-buffer-on-hot-restart t)
  (hover-minor-mode 1))

(use-package lsp-dart :ensure)
#+end_src

** rust
#+begin_src elisp
;; https://robert.kra.hn/posts/rust-emacs-setup

;; rustic = basic rust-mode + additions
(use-package rustic
  :ensure
  ;; :ensure-system-package rust-analyzer
  :bind (:map rustic-mode-map
              ;;("C-c C-c s" . lsp-rust-analyzer-status)
              ;;("C-c C-c e" . lsp-rust-analyzer-expand-macro)
              ;;("C-c C-c d" . dap-hydra)
              ;;("C-c C-c h" . lsp-ui-doc-glance)
              )
  :custom
  ;; This controls the overlays that display type and other hints inline. Enable
  ;; / disable as you prefer. Well require a `lsp-workspace-restart' to have an
  ;; effect on open projects.
  (lsp-rust-analyzer-server-display-inlay-hints t)
  (lsp-rust-analyzer-cargo-watch-command "clippy")
  (lsp-rust-analyzer-display-lifetime-elision-hints-enable "skip_trivial")
  (lsp-rust-analyzer-display-chaining-hints t)
  (lsp-rust-analyzer-display-lifetime-elision-hints-use-parameter-names nil)
  (lsp-rust-analyzer-display-closure-return-type-hints t)
  (lsp-rust-analyzer-display-parameter-hints nil)
  (lsp-rust-analyzer-display-reborrow-hints nil)
  :init
  (defun rk/rustic-mode-hook ()
    ;; so that run C-c C-c C-r works without having to confirm, but don't try to
    ;; save rust buffers that are not file visiting. Once
    ;; https://github.com/brotzeit/rustic/issues/253 has been resolved this should
    ;; no longer be necessary.
    (when buffer-file-name
      (setq-local buffer-save-without-query t))
    (add-hook 'before-save-hook 'lsp-format-buffer nil t))
  :hook
  (rustic-mode . rk/rustic-mode-hook))

;; unused for now
(defun company-yasnippet-or-completion ()
  (interactive)
  (or (do-yas-expand)
      (company-complete-common)))

(defun check-expansion ()
  (save-excursion
    (if (looking-at "\\_>") t
      (backward-char 1)
      (if (looking-at "\\.") t
        (backward-char 1)
        (if (looking-at "::") t nil)))))

(defun do-yas-expand ()
  (let ((yas/fallback-behavior 'return-nil))
    (yas/expand)))

(defun tab-indent-or-complete ()
  (interactive)
  (if (minibufferp)
      (minibuffer-complete)
    (if (or (not yas/minor-mode)
            (null (do-yas-expand)))
        (if (check-expansion)
            (company-complete-common)
          (indent-for-tab-command)))))

(use-package rust-playground :ensure)

(use-package toml-mode :ensure)

;;(use-package exec-path-from-shell
;;  :unless (eq system-type 'windows-nt)
;;  :ensure
;;  :init (exec-path-from-shell-initialize))

(use-package pest-mode :ensure)

(use-package flycheck-pest :ensure
  :after flycheck
  :config
  (flycheck-pest-setup))

(unless (eq system-type 'windows-nt)
  (use-package cmake-mode :ensure))

(use-package ninja-mode :ensure)

(use-package cargo-mode :ensure
  :demand :after rust-mode
  :hook (rust-mode . cargo-minor-mode))
#+end_src

** smartparens

#+begin_src emacs-lisp
; if M-<backspace> annoys - see this - https://github.com/Fuco1/smartparens/pull/861/files
(use-package smartparens
  :ensure
  :diminish ;; " sp"
  :after evil
  :init (evil-define-key 'motion global-map (kbd "<leader>[") 'hydra-sp/body)
  :functions (sp-pair sp-restrict-to-pairs-interactive)
  :config
  (require 'smartparens-config)
  (sp-use-smartparens-bindings)
  (smartparens-global-mode 1)
  ;; to be protected from introducing unbalanced pairs by editing commands which delete regions, what you want is smartparens-strict-mode
  ;;(smartparens-strict-mode)
  ;; otherwise it may fail during initial setup and package install
  (add-hook 'after-init-hook #'(lambda () (add-hook 'prog-mode-hook #'show-smartparens-mode)))
  (sp-pair "(" ")" :wrap "C-(") ;; how do people live without this?
  (sp-pair "[" "]" :wrap "s-[") ;; C-[ sends ESC
  (sp-pair "{" "}" :wrap "C-{")
  (bind-key "C-S-<left>" nil smartparens-mode-map)
  (bind-key "C-S-<right>" nil smartparens-mode-map)
  (bind-key "s-<delete>" 'sp-kill-sexp smartparens-mode-map)
  (bind-key "s-<backspace>" 'sp-backward-kill-sexp smartparens-mode-map)
  (bind-key "s-{" 'sp-rewrap-sexp smartparens-mode-map)
  ;; unbind the annoying one
  (unbind-key "M-<backspace>" smartparens-mode-map)
  :general
  ('insert 'smartparens-mode-map "C-S-h" 'sp-backward-slurp-sexp)
  ('insert 'smartparens-mode-map "C-S-l" 'sp-forward-slurp-sexp)
  :pretty-hydra
  (hydra-sp
   (:hint nil :title "Smartparens")
   ( "Moving"
     ( ("a" sp-beginning-of-sexp)
       ("e" sp-end-of-sexp)
       ("f" sp-forward-sexp)
       ("b" sp-backward-sexp)
       ("n" sp-down-sexp)
       ("N" sp-backward-down-sexp)
       ("p" sp-up-sexp)
       ("P" sp-backward-up-sexp))
     "Slurp & Barf"
     ;; Slurping & barfing
     ( ("h" sp-backward-slurp-sexp)
       ("H" sp-backward-barf-sexp)
       ("l" sp-forward-slurp-sexp)
       ("L" sp-forward-barf-sexp))
     ;; Wrapping
     "Sexp juggling"
     ( ("R" sp-rewrap-sexp)
       ("u" sp-unwrap-sexp)
       ("U" sp-backward-unwrap-sexp)
       ("(" sp-wrap-round)
       ("{" sp-wrap-curly)
       ("[" sp-wrap-square))
     ;; Sexp juggling
     "Destructive"
     ( ("S" sp-split-sexp)
       ("s" sp-splice-sexp)
       ("r" sp-raise-sexp)
       ("j" sp-join-sexp)
       ("t" sp-transpose-sexp)
       ("A" sp-absorb-sexp)
       ("E" sp-emit-sexp)
       ("o" sp-convolute-sexp))
     "Destructive"
     ( ("c" sp-change-inner :exit t)
       ("C" sp-change-enclosing :exit t)
       ("k" sp-kill-sexp)
       ("K" sp-backward-kill-sexp)
       ("w" sp-copy-sexp)
       ("q" nil)
       ("g" nil))))
  )

(use-package evil-smartparens
  :ensure
  :config (add-hook
           'after-init-hook
           #'(lambda ()
               (add-hook
                'emacs-lisp-mode-hook
                #'evil-smartparens-mode)))
  )

#+end_src

** code comments

#+begin_src emacs-lisp
(use-package evil-nerd-commenter
  :disabled ;; newcomment handles it
  :ensure
  :config
  (evilnc-default-hotkeys nil t)
  (evil-define-key 'motion 'global (kbd "<leader>;i") 'evilnc-comment-or-uncomment-lines)
)
#+end_src

** code highlights

#+begin_src emacs-lisp
(use-package rainbow-delimiters
  :ensure
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook #'(lambda () (add-hook 'prog-mode-hook #'rainbow-delimiters-mode)))
  )

(use-package rainbow-identifiers
  :ensure
  :config
  ;; otherwise during fresh install it may cycle autoloading
  (add-hook 'after-init-hook #'(lambda () (add-hook 'prog-mode-hook #'rainbow-identifiers-mode)))
  )
#+end_src

#+begin_src emacs-lisp
(use-package whitespace
  :ensure
  :defer 0.7
  :diminish (global-whitespace-mode . "") ;; " $"
  :custom
  (whitespace-line-column 210) ;; limit line length
  (whitespace-style
   '(face tabs ;; spaces
          trailing lines space-before-tab newline indentation empty space-after-tab ;; space-mark
          tab-mark newline-mark))
  (whitespace-global-modes '(prog-mode))
  ;;:hook (prog-mode . whitespace-mode) ;; this caused problems in sql-mode (dunno why), global mode + list of modes to enable works better
  ;; :config
  ;; (global-whitespace-mode)
  )
#+end_src

#+begin_src emacs-lisp
(use-package highlight-symbol
  :ensure
  :diminish " hls"
  :commands highlight-symbol
  :bind ("C-c h" . highlight-symbol))
#+end_src

#+begin_src emacs-lisp
(use-package hl-todo
  :ensure
  :disabled
  :config
  (setq hl-todo-keyword-faces
        '(("TODO"   . "#FF0000")
          ("todo"   . "#FF0000")
          ("FIXME"  . "#FF0000")
          ("fixme"  . "#FF0000")
          ("EXPERIMENT" . "#A020F0")
          ("DEBUG"  . "#A020F0")
          ("GOTCHA" . "#FF4500")
          ("why"    . "#FF4500")
          ("STUB"   . "#1E90FF")))
  ;; (("HOLD" . "#d0bf8f") ("TODO" . "#cc9393") ("NEXT" . "#dca3a3")
  ;;  ("THEM" . "#dc8cc3") ("PROG" . "#7cb8bb") ("OKAY" . "#7cb8bb")
  ;;  ("DONT" . "#5f7f5f") ("FAIL" . "#8c5353") ("DONE" . "#afd8af")
  ;;  ("NOTE" . "#d0bf8f") ("MAYBE" . "#d0bf8f") ("KLUDGE" . "#d0bf8f")
  ;;  ("HACK" . "#d0bf8f") ("TEMP" . "#d0bf8f") ("FIXME" . "#cc9393")
  ;;  ("XXXX*" . "#cc9393"))
  (define-key hl-todo-mode-map (kbd "C-c H p") 'hl-todo-previous)
  (define-key hl-todo-mode-map (kbd "C-c H n") 'hl-todo-next)
  (define-key hl-todo-mode-map (kbd "C-c H o") 'hl-todo-occur)
  (define-key hl-todo-mode-map (kbd "C-c H i") 'hl-todo-insert)
  ;; some problems with regex rxt-seq eval after update to 31
  ;; (add-hook 'prog-mode-hook 'hl-todo-mode)
  )
#+end_src

display colors visually

#+begin_src emacs-lisp
(use-package rainbow-mode
  :ensure :diminish " #"
  :custom (rainbow-html-colors t))
#+end_src

Prism - experimenting

#+begin_src emacs-lisp
(use-package prism
  :disabled
  :quelpa (prism :fetcher github :repo "alphapapa/prism.el")
  ;;:hook
  ;;(emacs-lisp-mode . prism-mode)
  ;;(java-mode . prism-mode)
  ;;(scala-mode . prism-mode)
  ;;(javascript-mode . prism-mode)
  ;;(sh-mode . prism-whitespace-mode)
  ;;(python-mode . prism-whitespace-mode)
  ) 
#+end_src

** code folding

#+begin_src emacs-lisp
;; integrates with evil-fold z-.. awesome!
(use-package origami
  :ensure
  :after evil
  :diminish " O"
  :general
  ;; amazing - aka org-mode TAB everywhere
  ('normal [remap indent-for-tab-command] 'evil-toggle-fold)
  ('normal "<backtab>" 'evil-open-folds)
  ('motion global-map (kbd "<leader>O") 'hydra-folding/body)
  :commands (hydra-folding/body)
  ;; I'm actually may use evil-fold-.. stuff..
  :pretty-hydra
  (hydra-folding
   (:color red :title "Folding")
   (""
    (("o" origami-open-node)
     ("c" origami-close-node)
     ("n" origami-next-fold)
     ("p" origami-previous-fold)
     ("f" origami-forward-toggle-node)
     ("a" origami-toggle-all-nodes)
     ("s" origami-show-only-node)))))

(use-package hs-minor-mode
  :config
  ;; otherwise it may fail to initialize emacs from scratch installing this package
  (add-hook 'after-init-hook #'(lambda () (add-hook 'prog-mode-hook #'hs-minor-mode))))

;; warn - this package depends on lsp-mode not from melpa-stable
(use-package lsp-origami
  :ensure
  :after lsp origami
  :hook (lsp-mode . (lambda () (hs-minor-mode -1) (lsp-origami-mode 1)))
  :bind
  ("C-S-t" . origami-toggle-node)
  ("C-S-c" . origami-toggle-all-nodes))
#+end_src

** docker

#+begin_src emacs-lisp
(use-package dockerfile-mode :ensure)

(use-package docker-compose-mode :ensure)

(use-package docker :ensure :bind ("C-c d" . docker))
#+end_src

** markdown

#+begin_src emacs-lisp
(use-package markdown-mode
  :ensure
  :commands (markdown-mode gfm-mode)
  :mode (("README\\.md\\'" . gfm-mode)
         ("\\.md\\'" . markdown-mode)
         ("\\.markdown\\'" . markdown-mode))
  :init (setq markdown-command "multimarkdown")
  :custom-face (markdown-code-face ((t (:inherit fixed-pitch :background "gray25"))))
)
#+end_src

** log-files

#+begin_src emacs-lisp
;; aka tail -f for log files (doesn't really work)
(add-to-list 'auto-mode-alist '("\\.log\\'" . auto-revert-mode))

(use-package logview :ensure :mode "\\.log\\(?:\\.[0-9]+\\)?\\'")
#+end_src

* * *system
** emacs tools

#+begin_src emacs-lisp
(use-package request
  :ensure
  :custom
  (request-log-level 'debug))

(use-package restart-emacs
  :ensure)
#+end_src

** multimedia & files
*** image scroll

#+begin_src emacs-lisp
; not using for now - it actually overrides good-scroll
;(add-hook 'after-init-hook
;         #'(lambda() (load-library "iscroll")))
#+end_src

*** emms

#+begin_src emacs-lisp
(use-package emms
  :ensure
  :disabled
  :config
  (emms-all)
  (emms-default-players)
  (define-emms-simple-player mplayer '(file url)
      (regexp-opt '(".ogg" ".mp3" ".wav" ".mpg" ".mpeg" ".wmv" ".wma"
                    ".mov" ".avi" ".divx" ".ogm" ".asf" ".mkv" "http://" "mms://"
                    ".rm" ".rmvb" ".mp4" ".flac" ".vob" ".m4a" ".flv" ".ogv" ".pls"))
      "mplayer" "-slave" "-quiet" "-really-quiet" "-fullscreen")
  ;; (define-emms-simple-player afplay '(file)
  ;;     (regexp-opt '(".mp3" ".m4a" ".aac"))
  ;;     "afplay")
  ;;   (setq emms-player-list `(,emms-player-afplay))
)
;; todo - xterm colors for shell
;;https://github.com/atomontage/xterm-color
#+end_src

*** doc
#+begin_src emacs-lisp
(use-package pdf-tools :ensure
  :config
  (pdf-tools-install)
  (define-key pdf-view-mode-map (kbd "SPC") nil)
  (evil-define-key 'normal pdf-view-mode-map (kbd "SPC") nil)
  )

(use-package djvu :ensure)

(use-package doc-view
  ;; :mode ("\\.odt\\'" . doc-view-mode)
  )

(use-package nov
  :ensure
  :mode ("\\.epub\\'" . nov-mode))
#+end_src

** shell, eshell, term
#+begin_src emacs-lisp
(use-package eshell
  :functions (eshell-smart-initialize)
  :after evil
  :init
  (defun eshell-new()
    "Open a new instance of eshell."
    (interactive)
    (eshell 'N))
  (evil-define-key 'motion global-map (kbd "<leader>e") 'eshell-new)
  :custom
  (eshell-history-size 12800)
  (eshell-where-to-jump 'begin)
  (eshell-banner-message "")
  :hook
  (eshell-mode
   . (lambda ()
       (setq-local global-hl-line-mode nil) ;; disable global mode
       (setq-local dimmer-mode nil) ;; disable global mode
       (eshell-smart-initialize)
       ;; (remove-hook 'window-scroll-functions 'eshell-smart-scroll-window)
       (remove-hook 'eshell-input-filter-functions 'eshell-smart-display-setup t)
       (move-point-on-insert-to-writeable-last-line)
       ;; why
       (general-def 'normal 'eshell-mode-map "M-h" nil)
       (general-def 'normal 'eshell-mode-map "M-l" nil)
       ;; (company-mode 1)
       (hack-dir-local-variables-non-file-buffer)
       ))
  :config
  ;; (require 'eshell-syntax-highlighting)
  ;; (require 'eshell-git-prompt)
  (require 'em-smart) ; smart eshell features
  (require 'em-term)
  ;; (add-to-list 'eshell-visual-commands "aider")
  (require 'eshell-z)
  ;; (defun my-eshell-debug-hook ()
  ;;   ;; (message "Eshell started in directory: %s" default-directory)
  ;;   ;; (message "Current projectile-project-name: %s" projectile-project-name)
  ;;   (hack-dir-local-variables-non-file-buffer)
  ;;   ;; (message "After hack-dir-local-variables-non-file-buffer, projectile-project-name: %s" projectile-project-name)
  ;;   )
  ;; (add-hook 'eshell-directory-change-hook #'my-eshell-debug-hook)
  ;; Force dir-locals to be applied when eshell starts
  ;; (advice-add 'eshell :after
  ;;             (lambda (&rest _)
  ;;               (hack-dir-local-variables-non-file-buffer)
  ;;               (message "Eshell started, projectile-project-name: %s" projectile-project-name)))
  (with-eval-after-load 'evil-collection
    (evil-collection-eshell-setup))

  ;;evil-insert-state-entry-hook
  (defun eshell-proper-clear ()
    (interactive)
    (let ((inhibit-read-only t))
      (erase-buffer)))
  ;; https://stackoverflow.com/a/46937891
  (defun move-point-to-writeable-last-line ()
    "Move the point to a non-read-only part of the last line.
If point is not on the last line, move point to the maximum position
in the buffer.  Otherwise if the point is in read-only text, move the
point forward out of the read-only sections."
    (interactive)
    (let* ((curline (line-number-at-pos))
           (endline (line-number-at-pos (point-max))))
      (if (= curline endline)
          (if (not (eobp))
              (let (
                    ;; Get text-properties at the current location
                    (plist (text-properties-at (point)))
                    ;; Record next change in text-properties
                    (next-change
                     (or (next-property-change (point) (current-buffer))
                         (point-max))))
                ;; If current text is read-only, go to where that property changes
                (if (plist-get plist 'read-only)
                    (goto-char next-change))))
        (goto-char (point-max)))))

  (defun move-point-on-insert-to-writeable-last-line ()
    "Only edit the current command in insert mode."
    (add-hook 'evil-insert-state-entry-hook
              'move-point-to-writeable-last-line
              nil
              t))
  )

(use-package eshell-z
  :ensure :after eshell)

(use-package eshell-vterm
  ;;:disabled
  :ensure :demand :after eshell
  :config (eshell-vterm-mode)
  (defalias 'eshell/v 'eshell-exec-visual)
  )

(use-package eshell-toggle
  :custom
  (eshell-toggle-size-fraction 3)
  (eshell-toggle-use-projectile-root t)
  (eshell-toggle-run-command nil)
  ;; (eshell-toggle-init-function #'eshell-toggle-init-ansi-term)
  :ensure
  ;;(evil-define-key 'motion global-map (kbd "<leader>e") 'eshell-new)
  :bind
  ("s-e" . eshell-toggle))

(use-package eshell-info-banner
  :ensure :after eshell
  ;;:hook ;; (eshell-banner-load . eshell-info-banner-update-banner)
  )

(use-package eshell-git-prompt
  :ensure
  :demand :after eshell
  :config (eshell-git-prompt-use-theme 'default))

(use-package eshell-syntax-highlighting
  :ensure
  :demand
  :after eshell
  :config
  (custom-set-faces '(eshell-prompt ((t :foreground "#a90034"))))
  ;;(setq eshell-highlight-prompt nil)
  ;; Enable in all Eshell buffers.
  (eshell-syntax-highlighting-global-mode 1))

(use-package fish-mode
  :ensure)

(use-package fish-completion
  :ensure
  :hook (eshell-mode . fish-completion-mode))

(use-package term
  :preface
  (defun term-zsh () (interactive) (term "/usr/bin/zsh"))
  (defun ansi-term-zsh () (interactive) (ansi-term "/usr/bin/zsh"))
  :hook (term-mode . (lambda ()
                       (setq-local global-hl-line-mode nil) ;; disable global mode in term
                       (bind-key "M-o" nil 'term-raw-map)))
  :custom
  (term-scroll-to-bottom-on-output t))

(use-package multi-term
  :ensure
  :after evil
  :init
  (defun my/open-term () (interactive)
         (tab-new)
         (multi-term)
         (set-window-dedicated-p (get-buffer-window (current-buffer)) t))
  (evil-define-key 'motion global-map (kbd "<leader>r") 'multi-term)
  (evil-define-key 'motion global-map (kbd "<leader>R") 'multi-term-dedicated-open)
  :config (setq multi-term-program "/usr/bin/fish") ;;"/usr/bin/zsh"
  :custom
  (multi-term-dedicated-select-after-open-p t)
  (multi-term-scroll-to-bottom-on-output t))

(use-package ansi-color
  :init
  (defun ansi-colorize-buffer ()
    (interactive)
    (ansi-color-apply-on-region (point-min) (point-max)))
  ;; ansi coloring in compilation-mode buffers (e.g. for dap-java-run-test-class)
  (defun colorize-compilation-buffer ()
    (read-only-mode t)
    (ansi-color-apply-on-region compilation-filter-start (point))
    (read-only-mode nil))
  :custom (ansi-color-names-vector ["#3c3836" "#fb4934" "#b8bb26" "#fabd2f" "#83a598" "#d3869b" "#8ec07c" "#ebdbb2"])
  :hook (compilation-filter . colorize-compilation-buffer))

;; testing this
(use-package shell-switcher
  :ensure
  :config
  (setq shell-switcher-mode t)
  (setq-default shell-switcher-new-shell-function 'eshell-new))

;; trying to solve coloring problems in 'shell'
;; do not change terminfo - this will break comints like sql.el etc
;; use term "zsh" instead
;;(setq comint-terminfo-terminal "dumb-emacs-ansi")
;;(setq comint-terminfo-terminal "dumb")
;; default
                                        ;dunno what it does
                                        ;(with-eval-after-load 'shell (set-face-attribute 'comint-highlight-prompt nil :inherit nil))

;; todo - group this bindings under some 'buffer' namespace with :after
(use-package comint
  :after evil
  ;; :bind (:map comint-mode-map ("M-n" . next-buffer) ("M-p" . previous-buffer))
  ;; :config
  ;; (evil-collection-define-key 'insert 'comint-mode-map
  ;;   (kbd "C-n") 'comint-next-input
  ;;   (kbd "C-p") 'comint-previous-input)
  )

(use-package powershell
  :config
  ;; Change default compile command for powershell
  (add-hook 'powershell-mode-hook
            (lambda ()
              (set (make-local-variable 'compile-command)
                   (format "powershell.exe -NoLogo -NonInteractive -Command \"& '%s'\""
                           (buffer-file-name)))))
  )
#+end_src

** vterm

#+begin_src emacs-lisp
(use-package vterm
  :ensure
  ;;:disabled
  :unless (eq system-type 'windows-nt)
  :config
  (define-key vterm-mode-map (kbd "M-m") nil)
  (define-key vterm-mode-map (kbd "M-h") nil)
  (define-key vterm-mode-map (kbd "M-l") nil)
  (define-key vterm-mode-map (kbd "M-k") nil)
  (define-key vterm-mode-map (kbd "M-o") nil)
  )
#+end_src

** powershell

#+begin_src emacs-lisp
(use-package powershell
  :ensure)
#+end_src

** system
*** systemd

#+begin_src emacs-lisp
;; systemd-mode
(use-package systemd
  :ensure)

;; evil in terminal - cursor shapes (doesn't work in gui)
;(add-hook 'evil-insert-state-entry-hook (lambda () (send-string-to-terminal "\033[5 q")))
;(add-hook 'evil-normal-state-entry-hook (lambda () (send-string-to-terminal "\033[0 q")))
#+end_src

*** terminal cursor

#+begin_src emacs-lisp
(if (eq system-type 'windows-nt)
  nil
  ;; terminal cursor (e.g. for evil)
  ;(quelpa '(term-cursor :repo "h0d/term-cursor.el" :fetcher github))
  ;;(global-term-cursor-mode)
  )

(use-package evil-terminal-cursor-changer
  :ensure
  :after evil
  :unless (or (display-graphic-p) (and (boundp 'server-process) server-process))
  ;; :disabled ;; when running emacs-server it still loads, and then it is a major performance degradation
  :config (add-hook 'after-init-hook #'evil-terminal-cursor-changer-activate))

#+end_src

*** sudo edit

#+begin_src emacs-lisp
;; to sudo-edit files
(use-package sudo-edit
  :ensure
  :disabled
  :general (motion "<leader> M-s" 'sudo-edit)
  :custom (sudo-edit-user user-login-name))

(use-package auto-sudoedit
  ;; no sudo on my android
  :unless (or (eq system-type 'windows-nt) is-android)
  :diminish :ensure
  :defer 2
  :after ivy
  :config (auto-sudoedit-mode))

; testing sudo
;(defun sudired ()
;  (interactive)
;  (require 'tramp)
;  (let ((dir (expand-file-name default-directory)))
;    (if (string-match "^/sudo:" dir)
;        (user-error "Already in sudo")
;      (dired (concat "/sudo::" dir)))))
;(define-key dired-mode-map "!" 'sudired)
#+end_src

*** docop
#+begin_src emacs-lisp
;;(use-package docopt)
#+end_src

*** i3wm

#+begin_src emacs-lisp
;; i3wm
(use-package i3wm-config-mode
  :ensure
  :hook (i3wm-config-mode . rainbow-mode))
#+end_src

*** exwm

#+begin_src emacs-lisp :tangle no
(use-package exwm
  :ensure
  :disabled
  :unless (eq system-type 'windows-nt)
  :config
  (require 'exwm-config)
  (setq exwm-input-global-keys `(,(kbd "s-&") .
                                 (lambda (command)
                                   (interactive (list (read-shell-command "$ ")))
                                   (start-process-shell-command command nil command))))
  (require 'exwm-systemtray)
  ;; didn't work
  ;;(exwm-systemtray-enable)
  ;; uncomment to start exwm
  ;;(exwm-config-default)
  )
#+end_src

*** other

#+begin_src emacs-lisp
(use-package ovpn-mode
  :ensure
  :mode ("\\.ovpn$" . conf-mode)
  :config
  ;;(evil-set-initial-state 'ovpn-mode 'emacs)
  (add-to-list 'evil-snipe-disabled-modes 'ovpn-mode)
  (evil-collection-define-key 'normal 'ovpn-mode-map
    "s" 'ovpn-mode-start-vpn
    "r" 'ovpn-mode-restart-vpn
    "q" 'ovpn-mode-stop-vpn
    "Q" 'ovpn-mode-stop-all
    "i" 'ovpn-mode-info-vpn
    "B" 'ovpn-mode-buffer-vpn
    "E" 'ovpn-mode-edit-vpn
    "d" 'ovpn-mode-dir-set
    "~" 'ovpn-mode-dir-filter
    "n" 'ovpn-mode-start-vpn-with-namespace
    "t" 'ovpn-mode-spawn-term-in-namespace
    "W" 'ovpn-mode-spawn-browser-in-namespace
    "a" 'ovpn-mode-active
    "6" (struct-ovpn-mode-platform-specific-ipv6-toggle ovpn-mode-platform-specific)
    "H" 'describe-mode)
  :custom (ovpn-mode-base-directory "~/vpn"))

(use-package arch-packer
  :ensure)

;; manage external services
(use-package prodigy
  :ensure
  :disabled)

(use-package proced
  :hook (proced-mode . (lambda () (proced-toggle-auto-update 1)))
  :custom (proced-auto-update-interval (if (eq system-type 'windows-nt) 15 5)))

(use-package vimrc-mode :ensure)

(use-package crontab-mode
  :mode "crontab"
  :ensure
  :init
  (defun crontab-e ()
    "Run `crontab -e' in a emacs buffer."
    (interactive)
    (with-editor-async-shell-command "crontab -e")))
#+end_src

** tramp

#+begin_src emacs-lisp
(use-package tramp
  :pin gnu
  :config
  ; not sure what it highlights
  ;(require 'tramp-theme)
  ;(load-theme 'tramp)
  (setq remote-file-name-inhibit-cache nil) ;; set if editing outside of tramp as well
  (setq vc-ignore-dir-regexp (format "%s\\|%s" vc-ignore-dir-regexp tramp-file-name-regexp))
  (setq tramp-verbose 4) ;; raise if debug tramp errors
  ;(setq tramp-connection-timeout 3) ; for debug
  ;(setq-default tramp-default-method "ssh")
  ;(setq-default tramp-default-method "scp")
  ;(setq tramp-default-user "twist") ;deprecated
  ;(setq tramp-default-host "localhost")
  ;(add-to-list 'tramp-default-user-alist '("\\`\\(?:doas\\|sudoedit\\|ksu\\|su\\(?:do\\)?\\)\\'" "localhost" "twist"))
  ;(setq tramp-syntax 'default) ; simplified | default | separate
)

(use-package counsel-tramp
  :ensure
  :after (counsel tramp)
  ;; this is to speed up tramp
  :hook
  (counsel-tramp-pre-command-hook . (lambda ()
                                      (global-aggressive-indent-mode 0)
                                      (projectile-mode 0)
                                      (editorconfig-mode 0)))
  (counsel-tramp-quit-hook . (lambda ()
                               (global-aggressive-indent-mode 1)
                               (projectile-mode 1)
                               (editorconfig-mode 1))))

(use-package tramp-theme
  :ensure)

#+end_src

** sauron
#+begin_src emacs-lisp
(use-package sauron
  :demand :after mu4e
  :ensure
  :config
  ;;(add-to-list 'evil-emacs-state-modes 'sauron-mode)
  ;; (setq sauron-hide-mode-line t)
  ;; (setq sauron-column-alist '((timestamp . 8)
  ;;                             (origin . 7)
  ;;                             (message)))
  ;; (setq sauron-timestamp-format "%H:%M:%S")
  (global-set-key (kbd "C-c s s") 'sauron-toggle-hide-show)
  (global-set-key (kbd "C-c s c") 'sauron-clear)
  (setq
   sauron-modules '(sauron-org sauron-notifications sauron-mu4e sauron-elfeed)
   sauron-max-line-length 120
   sauron-separate-frame nil
   sauron-dbus-cookie t
   sauron-min-priority 1
   ;; you probably want to add your own nickname to the these patterns
   sauron-watch-patterns '("emacs-fu" "emacsfu" "wombat" "capybara" "yak" "gnu" "\\bmu\\b")
   ;; you probably want to add you own nick here as well
   sauron-watch-nicks '("Tom" "Dick" "Harry"))
  ;; some sound/light effects for certain events
  (add-hook 'sauron-event-added-functions
            (lambda (origin prio msg &optional props)
              (sauron-fx-aplay "/usr/share/sounds/custom/bell_small.wav")
              ;; (if (string-match "ping" msg)
              ;;     (sauron-fx-sox "/usr/share/sounds/custom/bell_small.wav"))
              ;; (cond
              ;;  ((= prio 3) (sauron-fx-sox "/usr/share/sounds/pling.wav"))
              ;;  ((= prio 4) (sauron-fx-sox "/usr/share/sounds/plong.wav"))
              ;;  ((= prio 5)
	          ;;   ;;(sauron-fx-sox "/usr/share/sounds/alarm.wav")
	          ;;   ;;(sauron-fx-gnome-osd (format "%S: %s" origin msg) 5)
              ;;   ))
              ))
  ;; events to ignore
  (add-hook 'sauron-event-block-functions
            (lambda (origin prio msg &optional props)
              (or
               (string-match "^*** Users" msg)))) ;; filter out IRC spam
  (add-hook 'sauron-event-added-functions 'sauron-alert-el-adapter)
  (sauron-start-hidden)
  ;;(require 'sauron-mu4e)
  ;;(sauron-mu4e-start)
  (sauron-org-start)
  ;;(elfeed-update-background-start)
  ;;(sauron-elfeed-start)
  (sauron-add-event
   'kitchen           ;; origin
   2                  ;; priority
   "Coffee is ready!"
   '(lambda ()        ;; function called when activated
      (message "Coffee's ready, get it while it's hot!"))
   '(:temperature 80)) ;; arbitrary props passed to
  ;; hook functions
  )

;; dbus-send --session          	          \
;; --dest="org.gnu.Emacs"	                  \
;;  --type=method_call                           \
;;  "/org/gnu/Emacs/Sauron"                     \
;; "org.gnu.Emacs.Sauron.AddMsgEvent"           \
;; string:shell uint32:3 string:"Hello, world!"

#+end_src

** man pages
#+begin_src emacs-lisp
(use-package woman-mode
  :general (normal woman-mode-map "SPC" nil)
  )
#+end_src

* * *user*
** games & fun

#+begin_src emacs-lisp
(use-package 2048-game
  :ensure)
(use-package fireplace
  :ensure)
#+end_src

** accessibility
#+begin_src emacs-lisp
;; (pretty-hydra-define hydra-accessibility
;;   (:hint nil :color teal :quit-key "q" :title (with-faicon "universal-access" "Accessibility" 1 -0.05))
;;   ("TTS" (
;;           ("b" festival-say-buffer "festival bufer")
;;           ("r" festival-say-region "festival region")
;;           ("k" festival-kill-process "festival kill"))))

(defvar piper-tts-auto-region-num-lines 10)

(defun piper-read-region ()
  (interactive)
  (when (not mark-active)
    (beginning-of-line)
    (set-mark (point))
    (forward-line (1+ piper-tts-auto-region-num-lines)))
  (shell-command-on-region
   (region-beginning) (region-end)
   (if is-android
       ;; given that termux-api is installed
   "termux-tts-speak -r 0.9"
   ;; else linux
   (concat "piper-tts -q --model ~/documents/en_US-lessac-medium.onnx --sentence_silence 0.8 --output-raw | "
           ;;"aplay -q -r 22050 -f S16_LE -t raw -"
           "paplay --channels 1 --rate 22050 --format s16le --raw"
           )
   )
   nil
   ;; "*piper-out*"
   nil nil nil)
  (deactivate-mark)
  (recenter-top-bottom)
  )

(with-eval-after-load 'pretty-hydra
  (pretty-hydra-define+ hydra-text
    (:color teal :quit-key "q" :title (with-faicon "pencil" "Text" 1 -0.05))
    ("TTS" (("m" piper-read-region "piper read region")))))
#+end_src

** llm

#+begin_src emacs-lisp
;; doesn't work
(add-to-list 'display-buffer-alist '("\\*aider"
                                     (display-buffer-reuse-window display-buffer-in-side-window)
                                     (side . right)
                                     (slot . -1)
                                     (window-width . 0.5)
                                     (reusable-frames . nil)))

(defun comint-aider ()
  (interactive)
  (comint-run "aider" '("--no-attribute-commit-message-author"
                        "--no-attribute-author"
                        "--no-attribute-committe"
                        "--no-stream"
                        ;; "--multiline"
                        "--chat-mode" "ask"))
  (rename-buffer (concat "*aider-" (projectile-project-name) "*"))
  ;; (comint-send-string nil "/chat-mode ask")
  ;; (comint-send-input)
  ;; (comint-clear-buffer)
  )

(use-package gptel :ensure
  ;; :config
  ;; (setq
  ;;  ;; gptel-model 'claude-3-sonnet-20240229 ;  "claude-3-opus-20240229" also available
  ;;  gptel-backend (gptel-make-anthropic "Claude"
  ;;                  :stream t :key "<key>"))

  )

(use-package claude-code :ensure :requires vterm)
#+end_src

** hugo

#+begin_src emacs-lisp
(use-package ox-hugo
  :ensure
  :after ox org-capture
  :pin melpa
  :config
  ;; Populates only the EXPORT_FILE_NAME property in the inserted headline.
  (defun org-hugo-new-subtree-post-capture-template ()
    "Returns `org-capture' template string for new Hugo post.
See `org-capture-templates' for more information."
    (let* ((title (read-from-minibuffer "Post Title: ")) ; Prompt to enter the post title
           (fname (org-hugo-slug title)))
      (mapconcat #'identity
                 `(
                   ,(concat "* TODO " title)
                   ":PROPERTIES:"
                   ,(concat ":EXPORT_FILE_NAME: " fname)
                   ":END:"
                   "%?\n")          ;Place the cursor here finally
                 "\n")))
  (add-to-list 'org-capture-templates
               '("h"                ;`org-capture' binding + h
                 "Hugo post"
                 entry
                 ;; It is assumed that below file is present in `org-directory'
                 ;; and that it has a "Blog Ideas" heading. It can even be a
                 ;; symlink pointing to the actual location of all-posts.org!
                 (file+olp "blog.org" "Blog Ideas")
                 (function org-hugo-new-subtree-post-capture-template))))
#+end_src
** wordpress
#+begin_src emacs-lisp
(use-package org2blog
  :ensure
  :config
  ;;(org2blog-structure-template-add)
  ;;(add-to-list 'org-structure-template-alist '("wp" "@@wp:?@@"))
  :custom
  (org-export-preserve-breaks t)
  (org2blog/wp-use-sourcecode-shortcode t)
  (org2blog/wp-image-upload t)
  (org2blog/wp-image-thumbnails t)
  (org2blog/wp-track-posts nil) ;; (list "content.org" "org2blog-ostapchuk-posts") ;; pretty much useless
  (org2blog/wp-blog-alist
   `(("ostapchuk.xyz"
      :url "https://ostapchuk.xyz/xmlrpc.php"
      :username "twist522"
      :password ,(auth-source-pass-get 'secret "ostapchuk.xyz/twist522")
      )
     ("codefastdieyoung.com"
      :url "https://codefastdieyoung.com/xmlrpc.php"
      :username "twist522@gmail.com"
      :password ,(auth-source-pass-get 'secret "codefastdieyoung.com/twist522@gmail.com")
      )
     ))
  )
#+end_src

** ledger

#+begin_src emacs-lisp
(use-package ledger-mode
  :ensure
  :config
                                        ;(require 'flycheck-ledger)
  (add-to-list 'org-capture-templates '("l" "Ledger") t)
  (add-to-list 'org-capture-templates '("lb" "Bank" plain (file "ledger/journal.dat")
                                        "%(org-read-date) %^{Payee}\n\tExpenses:%^{Account}  %^{Ammount} UAH\n\tKredo" :empty-lines 1 :immediate-finish t))
  (add-to-list 'org-capture-templates ' ("lc" "Cash" plain (file "ledger/journal.dat")
                                         "%(org-read-date) * %^{Payee}\n\tExpenses:%^{Account}  %^{Amount} UAH\n\tCash" :empty-lines 1 :immediate-finish t))
  :bind
  ;;(:map ledger-mode-map ("M-n" . next-buffer) ("M-p" . previous-buffer))
  :hook (ledger-mode . (lambda ()
                         (setq-local indent-line-function #'ledger-indent-line)
                         (setq-local indent-region-function 'ledger-post-align-postings)
                         ))
  :custom
  ;;(ledger-binary-path "hledger")
  (ledger-reconcile-default-commodity nil)
  (ledger-reports
   '(("this month budget" "ledger budget expenses -p \"this month\" -X UAH")
     ("last-month-balance" "ledger [[ledger-mode-flags]] -f ~/documents/org/ledger/ledger.dat --monthly bal ^expenses -X UAH -p \"last month\"")
     ("last-month-expenses" "ledger [[ledger-mode-flags]] -f ~/documents/org/ledger/ledger.dat reg ^expenses -X UAH -p \"last month\" --monthly")
     ("bal" "%(binary) -f %(ledger-file) bal")
     ("reg" "%(binary) -f %(ledger-file) reg")
     ("payee" "%(binary) -f %(ledger-file) reg @%(payee)")
     ("account" "%(binary) -f %(ledger-file) reg %(account)")
     ))
  )

(use-package flycheck-ledger
  :ensure
  :demand :after ledger-mode)

(use-package hledger-mode
  :commands (hledger-run-command)
  :ensure
  :requires company-mode
  :hook (hledger-mode . (lambda ()
                          (make-local-variable 'company-backends)
                          (add-to-list 'company-backends 'hledger-company)))
  :config
  (evil-collection-define-key 'normal 'hledger-view-mode-map "gr" 'hledger-redo) ;; why should I define both for map and mode?
  (evil-collection-define-key 'normal 'hledger-view-mode "gr" 'hledger-redo)
  (evil-collection-define-key 'normal 'hledger-view-mode-map (kbd "<") 'hledger-prev-report)
  (evil-collection-define-key 'normal 'hledger-view-mode-map (kbd ">") 'hledger-next-report)
  (evil-collection-define-key 'normal 'hledger-view-mode "<" 'hledger-prev-report)
  (evil-collection-define-key 'normal 'hledger-view-mode ">" 'hledger-next-report)
  :custom
  ;;(hledger-date-regex "[0-9]\\{2\\}[-/][0-9]\\{2\\}")
  (hledger-jfile (concat org-directory "ledger/ledger.dat"))
  (hledger-currency-string "USD")
  (hledger-running-report-months 12)
  (hledger-extra-args " -X USD --infer-market-prices -S")
  (hledger-top-asset-account "Assets")
  (hledger-top-expense-account "Expenses")
  (hledger-top-income-account "Income")
  (hledger-ratios-income-accounts "Income")
  (hledger-ratios-assets-accounts "Assets")
  (hledger-ratios-debt-accounts "Liabilities")
  (hledger-ratios-liquid-asset-accounts "Assets")
  (hledger-reporting-day 1)
  (hledger-daily-report-accounts "Expenses")
  (hledger-show-only-unstarred-p nil)
  )

(use-package flycheck-hledger
  :ensure
  :demand :after hledger-mode)

;; (use-package evil-ledger
;;   :demand :after evil ledger-mode)
;; (fset 'euro
;;       (lambda (&optional arg) "Keyboard macro." (interactive "p")
;;         (kmacro-exec-ring-item (quote ([24 56 return 35 120 50 48 65 67 return] 0 "%d")) arg)))
#+end_src

** beancount

#+begin_src emacs-lisp
(use-package beancount
  :disabled
  :mode "\\.beancount\\'"
  :quelpa (beancount :repo "beancount/beancount-mode" :fetcher github)
  :hook
  (beancount-mode . (lambda () (setq-local electric-indent-chars nil)))
  (beancount-mode . outline-minor-mode)
  :bind (:map beancount-mode-map
              (("C-c C-n" . outline-next-visible-heading)
               ("C-c C-p" . outline-previous-visible-heading))))
#+end_src

#+RESULTS:

** elfeed

#+begin_src emacs-lisp
(use-package elfeed
  :disabled
  :ensure
  :bind ("C-c f" . elfeed)
  :config (elfeed-update)
  :custom (elfeed-search-filter "@6-months-ago +unread -ARCHIVE"))

(use-package elfeed-org
  :disabled
  :ensure
  :demand :after elfeed
  :custom
  (rmh-elfeed-org-files (list (concat org-directory "elfeed/feeds.org")))
  :config
  (define-advice elfeed (:after elfeed-update-each-time)
    "Update each time elfeed is launched."
    (elfeed-update))
  (elfeed-org)
  (elfeed-update))

(use-package elfeed-goodies
  :disabled
  :ensure
  :demand :after elfeed
  :config (elfeed-goodies/setup))

; this is for scoring entries, not using it now
(use-package elfeed-score
  :disabled
  :ensure
  :disabled
  :after evil
  :config 
  ;;(elfeed-score-enable)
  (evil-define-key 'normal elfeed-search-mode-map "=" elfeed-score-map))
#+end_src

** mail
#+begin_src emacs-lisp
(use-package message
  :init
  (when (not (eq system-type 'windows-nt))
    (progn
      (setq message-directory "~/.mail/")
      (setq gnus-directory "~/.config/emacs/news/")))

  :custom
  ;; smtp mail setting; these are the same that `gnus' uses.
  (message-send-mail-function 'smtpmail-send-it)
  (smtpmail-smtp-server "smtp.gmail.com")
  (smtpmail-smtp-service 587)
  (smtpmail-stream-type 'starttls)
  ;;smtpmail-default-smtp-server "smtp.example.com"
  ;;smtpmail-local-domain        "example.com"
  ;;smtp-queue-dir "~/.mail/gmail/sent wd/"
  )

(use-package notmuch
  :ensure
  )

(use-package gnus
  :disabled
  :custom
  (gnus-select-method `(nnimap "gmail.com"
                               (nnimap-user "twist522")
                               (nnimap-address "imap.gmail.com")
                               (nnimap-server-port 993)
                               (nnmail-expiry-wait immediate)))
  (gnus-message-archive-group "gmail/[Gmail]/Sent Mail")
                                        ;gnus-interactive-exit nil
                                        ;gnus-novice-user nil
                                        ;gnus-expert-user t
  (gnus-secondary-select-methods '((nntp "news.gmane.io"))))

                                        ;(bind-key "<delete" 'gnus-summary-delete-article gnus-summary-mode-map)

(use-package mu4e
  :disabled
  :unless (eq system-type 'windows-nt)
  :after evil
  :init (evil-define-key 'motion global-map (kbd "<leader>M") 'mu4e)
  ;;:preface
  :defines (mu4e~context-current mu4e~main-buffer-name)
  :functions (mu4e-update-mail-and-index)
  :commands (mu4e)
  ;;:config ;;(mu4e-update-mail-and-index t)
  ;; (add-to-list 'mu4e-view-actions ;; type ‘aV’, and the message opens inside a browse-url-generic-program
  ;;      '("ViewInBrowser" . mu4e-action-view-in-browser) t)
                                        ;:hook (mu4e-index-updated . (lambda () (shel-command "aplay /usr/share/sounds/custom/bell_small.wav&")))
  :custom
  (mail-user-agent 'mu4e-user-agent)
  (mu4e-display-update-status-in-modeline t)
  (mu4e-change-filenames-when-moving t)
  (message-kill-buffer-on-exit t)
  (shr-color-visible-luminance-min 80) ;; this helps a lot in dark theme
  
  (mu4e-bookmarks
   '((:name "Unread messages" :query "flag:unread AND NOT maildir:/Trash/" :key ?u) ;; AND NOT flag:trashed
     (:name "Today's messages" :query "date:today..now AND NOT maildir:/Trash/" :key ?t)
     (:name "Last 7 days" :query "date:7d..now AND NOT maildir:/Trash/" :hide-unread t :key ?w)
     (:name "All inboxes" :query "m:/twist/Inbox or m:/yuri/Inbox or m:/work/Inbox" :key ?i)
     ;;(:name "Messages with images" :query "mime:image/*" :key ?p)
     ))
  (mu4e-get-mail-command "mbsync -a") ;; set it to "true" will not run mbsync within emacs
  (mu4e-compose-signature (concat "Yuri Ostapchuk\n" "https://codefastdieyoung.xyz\n"))
  (mu4e-sent-messages-behavior 'delete) ;; gmail takes care of saving it
  (mu4e-view-show-images t) ;; seems this var is not defined?
  ;;(mu4e-use-fancy-chars t)
  (mu4e-update-interval 180) ;; update in background each 5min
  (mu4e-index-update-in-background t) ;; t is default, but I like it explicit
  (mu4e-maildir-shortcuts
   '((:maildir "/twist/Inbox"              :key ?i)
     (:maildir "/yuri/Inbox"               :key ?y)
     (:maildir "/work/Inbox"               :key ?w)
     (:maildir "/twist/band"               :key ?B)
     (:maildir "/twist/biz"                :key ?b)
     (:maildir "/twist/jobs"               :key ?j)
     ))
  (mu4e-icalendar-trash-after-reply t)
  :config
  (require 'shr)
  (require 'shr-color)
  (require 'mu4e-icalendar)
  (mu4e-icalendar-setup)
  (setq mu4e-main-buffer-name "*mu4e-main*")

  (defun mu4e-fast-update-mail-and-index (run-in-background)
    "Update only INBOX folder of the current context (fast update)."
    (interactive "P")
    (let ((mu4e-get-mail-command (concat "mbsync " (mu4e-context-name (mu4e-context-current)) ":INBOX")))
      (mu4e-update-mail-and-index run-in-background)))
  (evil-collection-define-key 'motion 'mu4e-main-mode-map "U" 'mu4e-fast-update-mail-and-index)

  ;; trash vs expunge see https://github.com/djcb/mu/issues/1136
  (setf (alist-get 'trash mu4e-marks)
        (list :char '("d" . "▼")
              :prompt "dtrash"
              :dyn-target (lambda (target msg)
                            (mu4e-get-trash-folder msg))
              :action (lambda (docid msg target)
                        ;; Here's the main difference to the regular trash mark,
                        ;; no +T before -N so the message is not marked as
                        ;; IMAP-deleted:
                        (mu4e--server-move docid (mu4e~mark-check-target target) "-N"))))
  (setq mu4e-contexts
        `( ,(make-mu4e-context
             :name "twist"
             :enter-func (lambda () (mu4e-message "Entering Personal context"))
             :leave-func (lambda () (mu4e-message "Leaving Personal context"))
             ;; we match based on the contact-fields of the message
             :match-func (lambda (msg)
                           (when msg
                             (mu4e-message-contact-field-matches msg
                                                                 :to "twist522@gmail.com")))
             :vars '((user-mail-address . "twist522@gmail.com")
                     (user-full-name . "Yuri Ostapchuk")
                     (smtpmail-smtp-user . "twist522@gmail.com")
                     (mu4e-drafts-folder . "/twist/[Gmail]/Drafts")
                     ;;mu4e-refile-folder "/archive"
                     (mu4e-sent-folder . "/twist/[Gmail]/Sent Mail")
                     (mu4e-trash-folder . "/twist/[Gmail]/Trash")
                     (mu4e-compose-signature . (concat "Yuri Ostapchuk\n" "https://codefastdieyoung.xyz\n"))
                     ))
           ,(make-mu4e-context
             :name "yuri"
             :enter-func (lambda () (mu4e-message "Switch to the Yuri context"))
             ;; no leave-func
             ;; we match based on the maildir of the message; assume all
             ;; cycling-related messages go into the /cycling maildir
             :match-func (lambda (msg)
                           (when msg
                             (string= (mu4e-message-field msg :maildir) "/yuri")))
             :vars '((user-mail-address . "yuri.ostapchuk@gmail.com")
                     (user-full-name . "Yuri Ostapchuk") ;
                     (smtpmail-smtp-user . "yuri.ostapchuk@gmail.com")
                     (mu4e-drafts-folder . "/yuri/[Gmail]/Drafts")
                     (mu4e-sent-folder . "/yuri/[Gmail]/Sent Mail")
                     (mu4e-trash-folder . "/yuri/[Gmail]/Trash")
                     (mu4e-compose-signature . (concat "Yuri Ostapchuk\n" "https://codefastdieyoung.xyz\n"))))
           ,(make-mu4e-context
             :name "work"
             :enter-func (lambda () (mu4e-message "Switch to the Work context"))
             ;; this matches maildir /Work and its sub-directories
             :match-func (lambda (msg)
                           (when msg
                             (string-match-p "^/work" (mu4e-message-field msg :maildir))))
             :vars `((user-mail-address . ,(auth-source-pass-get "Username" "dk/google.com"))
                     (user-full-name . "Yuri Ostapchuk")
                     (smtpmail-smtp-user . ,(auth-source-pass-get "Username" "dk/google.com"))
                     (mu4e-drafts-folder . "/work/[Gmail]/Drafts")
                     (mu4e-sent-folder . "/work/[Gmail]/Sent Mail")
                     (mu4e-trash-folder . "/work/[Gmail]/Trash")
                     (mu4e-compose-signature . (concat "Yuri Ostapchuk\n" "DataOps\n"))))

           ))
  )

(use-package mu4e-marker-icons
  :disabled
  :init (mu4e-marker-icons-mode 1))

;; (use-package sauron-mu4e
;;   :demand :after sauron mu4e)

(use-package mu4e-alert
  :disabled
  :ensure
  :demand :after mu4e sauron
  :init
  (setq ;; these stuff here is because of old mu4e-alert depending on older mu4e
   mu4e~main-buffer-name mu4e-main-buffer-name)
  :custom
  (mu4e-alert-notify-repeated-mails nil)
  (mu4e-alert-email-notification-types '(subjects))
  (mu4e-alert-interesting-mail-query "flag:unread AND NOT maildir:/Trash/")
  :config
  ;; todo - save/restore into file (with desktop?)
  ;;(ht->alist mu4e-alert-repeated-mails)
  ;;my/dump-vars-to-file

  (require 'sauron-mu4e)
  (setq sauron-mu4e-priority 3)
  (setq mu4e~context-current mu4e--context-current)
  (defun my/mu4e-alert-filter-repeated-mails (mails)
    "Filters the MAILS that have been seen already."
    (cl-remove-if (lambda (mail)
                    (prog1 (and (not mu4e-alert-notify-repeated-mails)
                                (ht-get mu4e-alert-repeated-mails
                                        (plist-get mail :message-id)))
                      (ht-set! mu4e-alert-repeated-mails
                               (plist-get mail :message-id)
                               t)))
                  mails))
  (defun my/sauron-mu4e-uread-messages (mails)
    "Add each email to the log.  Takes a list of mu4e mails as MAILS."
    (dolist (mail mails)
      (let ((log-message (funcall sauron-mu4e-formatter-function mail))
	        (callback (my/sauron-mu4e-make-link mail)))
        (sauron-add-event
         'mu4e
         sauron-mu4e-priority
         log-message
         callback))))
  (defun my/mu4e-alert-notify-unread-mail-async ()
    "Send a desktop notification about currently unread email."
    (mu4e-alert--get-mu-unread-mails (lambda (mails)
                                       (let ((new-mails (my/mu4e-alert-filter-repeated-mails mails)))
                                         (when (memql 'count mu4e-alert-email-notification-types)
                                           (mu4e-alert-notify-unread-messages-count (length new-mails)))
                                         (when (memql 'subjects mu4e-alert-email-notification-types)
                                           (progn
                                             (my/mu4e-alert-notify-unread-messages new-mails)
                                             ;;(my/sauron-mu4e-uread-messages new-mails)
                                             )
                                           )))))
  (defun my/mu4e-alert-notify-unread-messages (mails)
    "Display desktop notification for given MAILS."
    (let* ((mail-groups (funcall mu4e-alert-mail-grouper
                                 mails))
           (sorted-mail-groups (sort mail-groups
                                     mu4e-alert-grouped-mail-sorter))
           (notifications (mapcar (lambda (group)
                                    (funcall mu4e-alert-grouped-mail-notification-formatter
                                             group
                                             mails))
                                  sorted-mail-groups)))
      (dolist (notification (cl-subseq notifications 0 (min 5 (length notifications))))
        (alert (plist-get notification :body)
               :title (plist-get notification :title)
               :category "mu4e-alert"
               :icon mu4e-alert-icon))
      (dolist (mail mails)
        (with-temp-buffer
          (insert (format "%s" mail))
          (write-region (point-min) (point-max) "~/test.mails" t))
        )
      (when notifications
        (mu4e-alert-set-window-urgency-maybe))))

  ;;(setq mu4e-view-message-with-msgid 'mu4e-view-message-with-message-id)
  (defun my/sauron-mu4e-make-link (mail)
    "Make the callback link.  Takes a single mu4e mail as MAIL."
    (lambda () (message "this feature was disabled"))
    ;; this lexical-let just doesn't work
    ;; (lexical-let
    ;;     ((message-id (plist-get mail :message-id)))
    ;;   (lambda ()
    ;;     (switch-to-buffer "*mu4e-headers*")
    ;;     (mu4e-view-message-with-message-id message-id)))
    )
  ;;(advice-add 'sauron-mu4e-make-link :override #'my/sauron-mu4e-make-link)

  (mu4e-alert-set-default-style 'libnotify)
  ;;(mu4e-alert-enable-notifications)
  (my/mu4e-alert-notify-unread-mail-async)
  (mu4e-alert-enable-mode-line-display)
  (add-hook 'mu4e-index-updated-hook #'my/mu4e-alert-notify-unread-mail-async)
  ;;(advice-add 'mu4e-alert-filter-repeated-mails :override #'my/mu4e-alert-filter-repeated-mails)
  ;;(mu4e-alert-enable-mode-line-display)
  )



;; (mu4e-alert-notify-unread-messages-count 10)
;; (defun mu4e-alert-notify-unread-mail-async ()
;;   "Send a desktop notification about currently unread email."
;;   (mu4e-alert--get-mu-unread-mails (lambda (mails)
;;                                      (let ((new-mails (mu4e-alert-filter-repeated-mails mails)))
;;                                        (when (memql 'count mu4e-alert-email-notification-types)
;;                                          (mu4e-alert-notify-unread-messages-count (length new-mails)))
;;                                        (when (memql 'subjects mu4e-alert-email-notification-types)
;;                                          (mu4e-alert-notify-unread-messages new-mails))))))

(use-package mu4e-dashboard
  :disabled
  :quelpa (mu4e-dashboard :fetcher "github" :repo "rougier/mu4e-dashboard"))
#+end_src

** web
#+begin_src emacs-lisp
(when is-android
  (defun android-browse-url(url &optional share-url-instead)
    "browse url on android termux"
    (shell-command (concat "termux-open-url " url))))

(use-package eww
  :ensure
  :custom
  (browse-url-browser-function 'browse-url-default-browser)
  (eww-search-prefix "https://google.com/search?q=")
  :general
  (normal eww-mode-map "SPC" nil)
  ('motion "gX" 'browse-url-of-file)
  )

(use-package w3m
  :ensure
  :after general
  :config
  (general-def w3m-mode-map "M-l" nil "M-h" nil "M-k" nil)
  (general-def '(normal motion) w3m-mode-map "O" 'w3m-search)
  (add-hook
   'w3m-mode-hook
   #'(lambda ()
       (general-def '(normal motion) w3m-mode-map "SPC" nil)))
  :custom
  (w3m-use-header-line nil)
  (w3m-use-header-line-title nil)
  (w3m-use-tab nil)
  (w3m-use-tab-menubar nil)
  (w3m-use-toolbar nil)
  (w3m-display-mode 'plain)
  (w3m-use-tab-line nil))
#+end_src

** msgs
*** telega

#+begin_src emacs-lisp
(use-package telega
  :disabled
  :ensure
  :config (telega-notifications-mode))
#+end_src

*** slack
#+begin_src emacs-lisp :tangle no
(use-package emojify
  :disabled
  :ensure)

(use-package slack
  :disabled
  :after emojify
  :ensure
  :commands (slack-start)
  :init
  (setq slack-buffer-emojify t) ;; if you want to enable emoji, default nil
  (setq slack-prefer-current-team t)
  :hook (slack-mode . emojify-mode)
  :config
  (slack-register-team
   :name (auth-source-pass-get "name" "slack.com/work1")
   :default t
   :token (auth-source-pass-get 'secret "slack.com/work1")
   :cookie (auth-source-pass-get "cookie" "slack.com/work1")
   :subscribed-channels '(general)
   :full-and-display-names t)
  (evil-define-key 'normal slack-info-mode-map
    ",u" 'slack-room-update-messages)
  (evil-define-key 'normal slack-mode-map
    ",c" 'slack-buffer-kill
    ",ra" 'slack-message-add-reaction
    ",rr" 'slack-message-remove-reaction
    ",rs" 'slack-message-show-reaction-users
    ",pl" 'slack-room-pins-list
    ",pa" 'slack-message-pins-add
    ",pr" 'slack-message-pins-remove
    ",mm" 'slack-message-write-another-buffer
    ",me" 'slack-message-edit
    ",md" 'slack-message-delete
    ",u" 'slack-room-update-messages
    ",2" 'slack-message-embed-mention
    ",3" 'slack-message-embed-channel
    "\C-n" 'slack-buffer-goto-next-message
    "\C-p" 'slack-buffer-goto-prev-message)
   (evil-define-key 'normal slack-edit-message-mode-map
    ",k" 'slack-message-cancel-edit
    ",s" 'slack-message-send-from-buffer
    ",2" 'slack-message-embed-mention
    ",3" 'slack-message-embed-channel))
#+end_src

#+RESULTS:

** matrix
#+begin_src emacs-lisp
(use-package matrix-client
  :disabled t ;; this is an older client, ement.el is the new one
  :after bufler
  :quelpa (matrix-client :fetcher github :repo "alphapapa/matrix-client.el"
                         :files (:defaults "logo.png" "matrix-client-standalone.el.sh")))

(use-package plz
  :disabled
  :quelpa (plz :fetcher github :repo "alphapapa/plz.el"))

;; Install Ement.
(use-package ement
  :disabled
  :quelpa (ement :fetcher github :repo "alphapapa/ement.el"))
#+end_src

** other
#+begin_src emacs-lisp
(use-package google-maps
  :disabled
  :ensure)
#+end_src

* : custom

#+begin_src emacs-lisp
;;I'm not using custom, but have to keep this file writable - some functions fail otherwise
(customize-set-variable
 'custom-file ;'null-device "not storing"
 (expand-file-name "custom.el" user-emacs-directory)
 "keep customize settings in their own file")
;;(load custom-file)
#+end_src

* * simple.el
This is a WIP test simplified emacs configuration

#+begin_src emacs-lisp :noweb yes :tangle lisp/simple.el
<<package.el>>
<<use-package>>
<<startup>>
<<gruvbox>>
<<telephone-line>>
<<general>>
<<god>>
<<ivy>>
<<counsel>>
<<evil>>
<<evil-escape>>
<<tab-line>>
#+end_src

* * minimal.el
Minimal emacs config to be used instead of vim for quick edits, etc.
Sandbox for trying alternative libs as well.

#+begin_src emacs-lisp :noweb yes :tangle lisp/minimal.el
;;https://github.com/redguardtoo/emacs.d/blob/master/init.el

(setq gc-cons-percentage 0.6)
(setq gc-cons-threshold most-positive-fixnum)

;;(setq user-init-file (or load-file-name (buffer-file-name)))
;; (setq user-emacs-directory "/home/twist/.config/emacs/")
(setq user-init-file (or load-file-name (buffer-file-name)))
(setq user-emacs-directory (file-name-directory user-init-file))

(setq inhibit-startup-message t)
(setq inhibit-startup-screen t)
;; for this to work it has to be in init.el
(setq inhibit-startup-echo-area-message (user-login-name))
;;(fset 'display-startup-echo-area-message 'ignore)

;; doesn't work
;;(setq initial-buffer-choice "*Messages*")

(setq initial-scratch-message nil)

(setq default-frame-alist
      '((menu-bar-lines . 0)
        (tool-bar-lines . 0)
        (horizontal-scroll-bars)
        (vertical-scroll-bars)))

(setq make-backup-files nil)


;; speed up slow file loading caused by regex matching caused by default value of this variable
(let* ((file-name-handler-alist nil))
  (require ' package)
  (add-to-list 'package-archives '("melpa". "https://melpa.org/packages/"))
  ;;(setq package-quickstart t) ;; I don't really understand how this works
  ;; Minimal initialization
  (setq package-enable-at-startup nil)
  ;; I could do this and than package-initialize but this is not convenient
  ;;(setq package-load-list '((gruvbox-theme t) (autothemer t) (dash t)))
  (package-initialize 'no-activate)

  ;; (unless (package-installed-p 'use-package)
  ;;   (package-refresh-contents)
  ;;   (package-install 'use-package))
  ;; (require 'use-package)
  ;; (setq use-package-always-defer t)
  ;; (use-package doom-themes :ensure)

  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/doom-themes-2.3.0"))
  ;; (load "doom-themes-autoloads")
  ;; (load-theme 'doom-one t)
  ;; (doom-themes-org-config)

  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/dash-2.19.1"))
  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/autothemer-0.2.18"))
  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/gruvbox-theme-20240615.432"
  ;;                                 ;; "elpa/gruvbox-theme-1.30.1"
  ;;                                 ))
  (package-activate 'gruvbox-theme)
  ;;(require 'gruvbox-theme)
  (load-theme 'gruvbox-dark-hard t)


  (set-face-attribute 'default nil :font "Fira Code" :height 122)


  (require 'tab-line)
  (set-face-attribute 'tab-line nil :foreground "#fdf4c1" :background "#1d2021"
                      :distant-foreground "#fdf4c1" :distant-foreground 'unspecified
                      :family "Fira Sans Condensed 18" :height 1.0 :box nil) ;; background behind tabs
  (set-face-attribute 'tab-line-tab nil :inherit 'tab-line :box nil :background "#1d2021") ;; active tab in another window
  (set-face-attribute 'tab-line-tab-current nil :inverse-video t :box nil :background "#1d2021") ;; active tab in current window
  (set-face-attribute 'tab-line-tab-inactive nil :background "#3c3836") ;; inactive tab
  (set-face-attribute 'tab-line-highlight nil :box nil :background "#4c4846" :foreground 'unspecified) ;; mouseover
  (setq tab-line-new-button-show nil)
  (setq tab-line-close-button-show nil)
  (global-tab-line-mode)



  ;; (require 'tab-bar)
  ;; (setq tab-bar-tab-hints t)
  ;; (setq tab-bar-close-button-show nil)
  ;; (setq tab-bar-close-button-show nil)
  ;; (setq tab-bar-select-tab-modifiers '(meta))
  ;; (tab-bar-mode)


  (set-face-attribute 'default nil :font "Fira Code" :height 122)

  (package-activate 'telephone-line)
  ;;(add-to-list 'load-path (concat user-emacs-directory "elpa/telephone-line-20240109.2021"))
  (require 'telephone-line)
  (require 'telephone-line-segments)
  ;; (defun telephone-line-modal-face (active)
  ;;   (cond ((not active) 'mode-line-inactive)
  ;;         ((and meow-normal-mode (region-active-p)) 'telephone-line-evil-visual)
  ;;         (meow-normal-mode 'telephone-line-evil-normal)
  ;;         (meow-insert-mode 'telephone-line-evil-insert)
  ;;         (meow-motion-mode 'telephone-line-evil-emacs)
  ;;         (meow-keypad-mode 'telephone-line-evil-operator)
  ;;         (meow-beacon-mode 'telephone-line-evil-replace)))
  (setq telephone-line-lhs
        '((evil   . (telephone-line-evil-tag-segment))
          ;; (modal  . (telephone-line-meow-tag-segment))
          (accent . (telephone-line-vc-segment
                     telephone-line-process-segment))
          (nil    . (telephone-line-project-buffer-segment))))
  (telephone-line-mode 1)




  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/vertico-1.8"))
  ;; Enable vertico
  (package-activate 'vertico)
  ;; (require 'vertico)
  (vertico-mode)

  ;; Different scroll margin
  ;; (setq vertico-scroll-margin 0)

  ;; Show more candidates
  (setq vertico-count 16)

  ;; Grow and shrink the Vertico minibuffer
  ;; (setq vertico-resize t)

  ;; Optionally enable cycling for `vertico-next' and `vertico-previous'.
  ;; (setq vertico-cycle t)

  ;; Persist history over Emacs restarts. Vertico sorts by history position.
  (require 'savehist)
  (savehist-mode)

  ;; A few more useful configurations...
  ;; Add prompt indicator to `completing-read-multiple'.
  ;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
  (defun crm-indicator (args)
    (cons (format "[CRM%s] %s"
                  (replace-regexp-in-string
                   "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
                   crm-separator)
                  (car args))
          (cdr args)))
  (advice-add #'completing-read-multiple :filter-args #'crm-indicator)

  ;; Do not allow the cursor in the minibuffer prompt
  (setq minibuffer-prompt-properties
        '(read-only t cursor-intangible t face minibuffer-prompt))
  (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)

  ;; Support opening new minibuffers from inside existing minibuffers.
  (setq enable-recursive-minibuffers t)

  ;; Emacs 28 and newer: Hide commands in M-x which do not work in the current
  ;; mode.  Vertico commands are hidden in normal buffers. This setting is
  ;; useful beyond Vertico.
  (setq read-extended-command-predicate #'command-completion-default-include-p)



  (package-activate 'consult)



  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/orderless-1.1"))
  ;; Optionally use the `orderless' completion style.
  ;; (require 'orderless)
  (package-activate 'orderless)
  ;; Configure a custom style dispatcher (see the Consult wiki)
  ;; (setq orderless-style-dispatchers '(orderless-flex orderless-initialism)
  ;;       orderless-component-separator #'orderless-escapable-split-on-space)
  (setq orderless-matching-styles '(orderless-flex orderless-prefixes))
  (setq completion-styles '(orderless basic)
        completion-category-defaults nil
        completion-category-overrides '((file (styles partial-completion))))




  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/marginalia-1.6"))
  ;; Enable rich annotations using the Marginalia package
  (package-activate 'marginalia)
  ;; Bind `marginalia-cycle' locally in the minibuffer.  To make the binding
  ;; available in the *Completions* buffer, add it to the
  ;; `completion-list-mode-map'.
  ;; :bind (:map minibuffer-local-map
  ;;             ("M-A" . marginalia-cycle))
  (marginalia-mode)



  (package-activate 'embark)
  (define-key global-map (kbd "C-.") 'embark-act)
  (define-key global-map (kbd "C-;") 'embark-dwim)
  (define-key global-map (kbd "C-h B") 'embark-bindings)
  (setq prefix-help-command #'embark-prefix-help-command)
  ;; 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))))

  ;; Consult users will also want the embark-consult package.
  (package-activate 'embark-consult)
  (add-hook 'embark-collect-mode #'consult-preview-at-point-mode)


  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/evil-1.15.0"))
  (package-activate 'evil)
  ;; (require 'evil)
  (evil-mode)

  (define-key global-map (kbd "M-o") 'other-window)
  (define-key global-map (kbd "M-s") 'save-buffer)
  (define-key global-map (kbd "M-d") 'delete-window)
  (define-key global-map (kbd "M-j") 'quit-window)
  (define-key global-map (kbd "M-k") 'quit-window-kill-buffer)
  (define-key global-map (kbd "M-h") 'tab-line-switch-to-prev-tab)
  (define-key global-map (kbd "M-l") 'tab-line-switch-to-next-tab)

  ;; (add-to-list 'load-path (concat user-emacs-directory "elpa/meow-1.4.5"))
  ;; (package-activate 'meow)

  ;; (defun meow-setup ()
  ;;   (setq meow-cheatsheet-layout meow-cheatsheet-layout-qwerty)
  ;;   (meow-motion-overwrite-define-key
  ;;    '("j" . meow-next)
  ;;    '("k" . meow-prev)
  ;;    '("<escape>" . ignore))
  ;;   (defun find-config-org () (interactive)
  ;;          (find-file (file-truename (concat user-emacs-directory "config.org"))))
  ;;   (meow-leader-define-key
  ;;    ;; SPC j/k will run the original command in MOTION state.
  ;;    '("j" . "H-j")
  ;;    '("k" . "H-k")
  ;;    '("w |" . split-window-right)
  ;;    '("w _" . split-window-below)
  ;;    '("d" . dired-jump)
  ;;    '("f" . find-file)
  ;;    '("u i" . find-config-org)
  ;;    ;; Use SPC (0-9) for digit arguments.
  ;;    '("1" . meow-digit-argument)
  ;;    '("2" . meow-digit-argument)
  ;;    '("3" . meow-digit-argument)
  ;;    '("4" . meow-digit-argument)
  ;;    '("5" . meow-digit-argument)
  ;;    '("6" . meow-digit-argument)
  ;;    '("7" . meow-digit-argument)
  ;;    '("8" . meow-digit-argument)
  ;;    '("9" . meow-digit-argument)
  ;;    '("0" . meow-digit-argument)
  ;;    '("/" . meow-keypad-describe-key)
  ;;    '("?" . meow-cheatsheet))
  ;;   (defun quit-window-kill-buffer ()
  ;;     (interactive)
  ;;     (quit-window t))
  ;;   (dolist (mode '(insert normal motion))
  ;;     (meow-define-keys mode
  ;;                       '("M-o" . other-window)
  ;;                       '("M-s" . save-buffer)
  ;;                       '("M-d" . delete-window)
  ;;                       '("M-j" . quit-window)
  ;;                       '("M-k" . quit-window-kill-buffer)
  ;;                       '("M-h" . tab-line-switch-to-prev-tab)
  ;;                       '("M-l" . tab-line-switch-to-next-tab)
  ;;                       ;; '("s-j" . scroll-up-command)
  ;;                       ;; '("s-k" . scroll-down-command)
  ;;                       )
  ;;     )
  ;;   (defun meow-visual-rectangle-mode ()
  ;;     "Toggle rectangle-mark-mode and enter visual state."
  ;;     (interactive)
  ;;     (if rectangle-mark-mode
  ;;         (rectangle-mark-mode -1)
  ;;       (rectangle-mark-mode 1))
  ;;     (meow-visual-mode 1))

  ;;   (defun meow-rectangle-toggle ()
  ;;     "Toggle rectangle-mark-mode and switch to motion state."
  ;;     (interactive)
  ;;     (if rectangle-mark-mode
  ;;         (rectangle-mark-mode -1)
  ;;       (rectangle-mark-mode 1))
  ;;     (meow-motion-mode 1))

  ;;   (meow-normal-define-key
  ;;    '("0" . meow-expand-0)
  ;;    '("9" . meow-expand-9)
  ;;    '("8" . meow-expand-8)
  ;;    '("7" . meow-expand-7)
  ;;    '("6" . meow-expand-6)
  ;;    '("5" . meow-expand-5)
  ;;    '("4" . meow-expand-4)
  ;;    '("3" . meow-expand-3)
  ;;    '("2" . meow-expand-2)
  ;;    '("1" . meow-expand-1)
  ;;    '("-" . negative-argument)
  ;;    '(";" . meow-reverse)
  ;;    '("," . meow-inner-of-thing)
  ;;    '("." . meow-bounds-of-thing)
  ;;    '("[" . meow-beginning-of-thing)
  ;;    '("]" . meow-end-of-thing)
  ;;    '("a" . meow-append)
  ;;    '("A" . meow-open-below)
  ;;    '("b" . meow-back-word)
  ;;    '("B" . meow-back-symbol)
  ;;    '("c" . meow-change)
  ;;    '("d" . meow-delete)
  ;;    '("D" . meow-backward-delete)
  ;;    '("e" . meow-next-word)
  ;;    '("E" . meow-next-symbol)
  ;;    '("f" . meow-find)
  ;;    '("g" . meow-cancel-selection)
  ;;    '("G" . meow-grab)
  ;;    '("h" . meow-left)
  ;;    '("H" . meow-left-expand)
  ;;    '("i" . meow-insert)
  ;;    '("I" . meow-open-above)
  ;;    '("j" . meow-next)
  ;;    '("J" . meow-next-expand)
  ;;    '("k" . meow-prev)
  ;;    '("K" . meow-prev-expand)
  ;;    '("l" . meow-right)
  ;;    '("L" . meow-right-expand)
  ;;    '("m" . meow-join)
  ;;    '("n" . meow-search)
  ;;    '("o" . meow-block)
  ;;    '("O" . meow-to-block)
  ;;    '("p" . meow-yank)
  ;;    '("q" . meow-quit)
  ;;    '("Q" . meow-goto-line)
  ;;    '("r" . meow-replace)
  ;;    '("R" . meow-swap-grab)
  ;;    '("s" . meow-kill)
  ;;    '("t" . meow-till)
  ;;    '("u" . meow-undo)
  ;;    '("U" . meow-undo-in-selection)
  ;;    '("v" . meow-visit)
  ;;    '("V" . meow-visual-rectangle-mode)
  ;;    '("w" . meow-mark-word)
  ;;    '("W" . meow-mark-symbol)
  ;;    '("x" . meow-line)
  ;;    '("X" . meow-goto-line)
  ;;    '("y" . meow-save)
  ;;    '("Y" . meow-sync-grab)
  ;;    '("z" . meow-pop-selection)
  ;;    '("'" . repeat)
  ;;    '("<escape>" . ignore)))
  ;; (require 'meow)
  ;; (meow-setup)
  ;; (meow-global-mode 1)


  ;; (package-activate 'boon)
  ;; (require 'boon-qwerty)
  ;; (require 'boon-hl)
  ;; (boon-mode)
  


  (add-hook 'prog-mode-hook #'subword-mode)



  (require 'dired)

  (setq dired-listing-switches "-AGhlv --group-directories-first --time-style=long-iso")
  (setq delete-by-moving-to-trash t)
  (setq dired-kill-when-opening-new-dired-buffer t)
  (define-key dired-mode-map "l" 'dired-find-file)
  (define-key dired-mode-map "h" 'dired-up-directory)



  )

(defun my-cleanup-gc ()
  "Clean up gc."
  (setq gc-cons-threshold  67108864) ; 64M
  (setq gc-cons-percentage 0.1) ; original value
  (garbage-collect))

(run-with-idle-timer 4 nil #'my-cleanup-gc)

(message "*** Emacs loaded in %s with %d garbage collections."
         (format "%.2f seconds"
                 (float-time (time-subtract after-init-time before-init-time)))
         gcs-done)
#+end_src

* : provide
#+begin_src emacs-lisp
(provide 'config)
#+end_src