(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
;; Also see `package-archive-priorities` and `package-pinned-packages`.
(package-initialize)
;; This is only needed once, near the top of the file
(eval-when-compile
  ;; Following line is not needed if use-package.el is in ~/.emacs.d
  (add-to-list 'load-path "<path where use-package is installed>")
  (require 'use-package))

;;; Setup EXWM
(use-package exwm :ensure t
  :custom ;; move/resize floating buffers 
  ;; with Alt left-click/Alt right-click
  (exwm-input-move-event [M-down-mouse-1])
  (exwm-input-resize-event [M-down-mouse-3])
  ;; make window borders easier to grab to
  ;; enable resizing outside the modeline
  (exwm-floating-border-width 2)
  (window-divider-default-right-width 6)
  (window-divider-default-bottom-width 0) ;; use the modeline
  (desktop-environment-update-exwm-global-keys nil)
  ;; use a larger systemtray for (exwm-systemtray-mode)
  (exwm-systemtray-height 32)
  ;; Make buffer name more meaningful
  (exwm-update-title-hook
   '((lambda nil
       (exwm-workspace-rename-buffer exwm-class-name))))
  ;; always enable switching to any buffer from any workspace
  (exwm-workspace-show-all-buffers t)
  :config
  ;; Allow resizing with mouse, of non-floating windows.
  (setq window-divider-default-bottom-width 2)
  ;; do not open new frame for ediff: that would break
  (setq ediff-window-setup-function #'ediff-setup-windows-plain)
  (window-divider-mode)
  ;; show the time in the modeline (also see the customization in the variables)
  (display-time-mode)
  ;; disable CTRL-z (pause), because it breaks my workflows and exwm
  (global-unset-key (kbd "C-z")))

;;; Start pinentry, so passwords for ssh and gnupg use Emacs mechanisms
(use-package pinentry
  :ensure t
  :config
  (pinentry-start))

;;; Setup type-break mode such that it does not block EXWM
(use-package type-break
  :custom
  (type-break-demo-boring-stats t)
  (type-break-mode-line-message-mode t)
  :config
  ;; ignore errors for type-break mode. A missing type-break stats
  ;; file can break startup otherwise.
  (ignore-errors (type-break-mode t))
  ;; the regular y-or-n-p or yes-or-no-p break exwm when in an X11 window.
  (add-hook 'exmw-init
            (lambda ()
              (setq type-break-query-function
                    (lambda (msg)
                      (ding)
                      (alert msg
                             :severity 'high
                             :title "M-x type-break"
                             :icon "warning"))))))

M-x exwm-init

wmctrl -m
# in guix you can install and run it in one step:
# guix shell wmctrl -- wmctrl -m

;; Enable exwm-randr before exwm-init gets called
(use-package exwm-randr
  ;; :if dw/exwm-enabled
  :after (exwm)
  :custom
  ;; two workspaces
  (exwm-workspace-number 2)
  ;; move the second workspace to the secondary monitor, 
  ;; the others are on the primary display
  (exwm-randr-workspace-monitor-plist '(1 "DP-1"))
  ;; enable switching to any buffer from any workspace
  (exwm-workspace-show-all-buffers t)
  (exwm-layout-show-all-buffers t)
  :config
  (exwm-randr-enable)
  ;; update the screen setup when a screen is turned on or off
  (add-hook 'exwm-randr-screen-change-hook
            (lambda ()
              (start-process-shell-command
               "xrandr" nil 
  "xrandr --output HDMI-3 --primary --auto --pos 0x0 --output DP-1 --auto --pos 1920x120"))))

(use-package desktop-environment :ensure t
  :custom
  (desktop-environment-screenshot-directory "~/Bilder")
  (desktop-environment-volume-normal-decrement "-5%")
  (desktop-environment-volume-normal-increment "+5%")
  (desktop-environment-volume-get-command
   "LC_ALL=C pacmd list-sinks|grep -A 15 '* index'| awk '/volume: front/{ print $5 }' | sed 's/,//g'")
  (desktop-environment-volume-set-command 
   ;; auto-detect the active sink.
   "LC_ALL=C pactl set-sink-volume $(pacmd list-sinks|grep -o '* index.*' | grep -o ':.*' | cut -c 2-) %s")
  (desktop-environment-volume-small-decrement "-1%")
  (desktop-environment-volume-small-increment "+1%")
  :config
  (desktop-environment-mode)
  ;; the sigma and pi commands are optimized for https://www.neo-layout.org/
  (global-set-key (kbd "M-σ") 'desktop-environment-volume-decrement-slowly)
  (global-set-key (kbd "M-π") 'desktop-environment-volume-increment-slowly)
  (global-set-key (kbd "M--") 'desktop-environment-volume-decrement)
  (global-set-key (kbd "M-+") 'desktop-environment-volume-increment))


(define-minor-mode display-volume-mode
  "Toggle display of volume in mode lines.

Depends on desktop-environment.

When Display Time mode is enabled, it queries the volume from
your system on every displaying using
desktop-environment-volume-get (which you can customize)."
  :global t :group 'desktop-environment
  (or global-mode-string (setq global-mode-string '("")))
  (setq display-volume-keymap (make-sparse-keymap))
  (define-key display-volume-keymap (kbd "<mode-line> <mouse-4>") 
   'desktop-environment-volume-increment-slowly)
  (define-key display-volume-keymap (kbd "<mode-line> <mouse-5>")
   'desktop-environment-volume-decrement-slowly)
  (setq display-volume-modeline-entry
        '(:eval (propertize (format " V:%s%% "(desktop-environment-volume-get))
                            'keymap display-volume-keymap)))
  (if display-volume-mode
      (progn
        (or (memq display-volume-modeline-entry global-mode-string)
            (setq global-mode-string
                  (append global-mode-string (list display-volume-modeline-entry)))))))

(display-volume-mode)

(defun make-window-dedicated (arg)
  "Set the current window as dedicated, 
so it will not be chosen as target for other buffers.
With C-u (ARG != 1; some prefix argument) 
set window as non-dedicated."
  (interactive "p")
  (set-window-dedicated-p nil (if (= 1 arg) t nil)))

(use-package ido-completing-read+ :ensure t :defer 1
  :config
  ;; disable ido-cr+ where it does not fit.
  (add-to-list 'ido-cr+-disable-list 'journal t)
  (add-to-list 'ido-cr+-disable-list 'gnus-mime-save-part t)
  (add-to-list 'ido-cr+-disable-list 'bbdb-read-string)
  :custom
  (ido-cr+-auto-update-blacklist t)
  (ido-cr+-function-whitelist nil)
  (ido-cr+-max-items 30000)
  (ido-cr+-replace-completely nil)
  (ido-ubiquitous-mode t))

(use-package ido-preview ;; no need to ensure: it is part of emacs
  :defer 2
  :config
  (add-hook 'ido-setup-hook
            (lambda()
              (define-key ido-completion-map (kbd "C-M-p") (lookup-key ido-completion-map (kbd "C-p")))
              (define-key ido-completion-map (kbd "C-M-n") (lookup-key ido-completion-map (kbd "C-n"))) ; currently, this makes nothing. Maybe they'll make C-n key lately.
              (define-key ido-completion-map (kbd "C-p") 'ido-preview-backward)
              (define-key ido-completion-map (kbd "C-n") 'ido-preview-forward)))
  ;; disable ido where it does not fit.
  (add-to-list 'ido-read-file-name-non-ido 'journal t)
  (add-to-list 'ido-read-file-name-non-ido 'gnus-mime-save-part t)
  :custom
  (ido-all-frames t)
  (ido-buffer-disable-smart-matches nil)
  (ido-enable-dot-prefix t)
  (ido-enable-flex-matching t)
  (ido-everywhere t)
  (ido-max-work-file-list 10)
  (ido-max-dir-file-cache 20)
  ;; reduce number of prospects to reduce window size changes
  (ido-max-prospects 10)
  (ido-mode (quote both) nil (ido))
  (ido-read-file-name-non-ido
   '(tramp-rename-these-files tramp-rename-files
     journal gnus-mime-save-part))
  (ido-use-filename-at-point (quote guess))
  (ido-use-url-at-point t))

;; Ignore ido save errors; they can block emacs shutdown on disk-full,
;; and the history is not important enough for that.
(defun ido-kill-emacs-hook ()
  (ignore-errors (ido-save-history)))

;; my disable list for ido-cr+:
;; (ido-cr+-disable-list 
;;  '(read-file-name-internal read-buffer
;;   internal-complete-buffer todo-add-category
;;   gnus-emacs-completing-read gnus-iswitchb-completing-read
;;   grep-read-files magit-builtin-completing-read ess-completing-read
;;   Info-read-node-name tmm-prompt org-tags-completion-function
;;   ffap-read-file-or-url ffap-read-file-or-url-internal
;;   sly-read-symbol-name org-olpath-completing-read bbdb-read-string
;;   journal gnus-mime-save-part)

;; add demo images to type-break
(use-package slideview :ensure t
  :config
  (add-hook 'image-mode-hook 'slideview-mode)
  (defun type-break-demo-slideview ()
    "Take a typing break with a training slideshow."
    (and (get-buffer "*Slideview*")
         (kill-buffer "*Slideview*"))
    (condition-case ()
        (progn
          (with-temp-buffer
            (rename-buffer "*Slideview*")
            (let* ((files (directory-files
                           "~/.guix-profile/share/workrave/exercises/" t))
                   (len-files (length files))
                   ;; compensate that random selection of a range
                   ;; start favors later entries.
                   (compensate 5)
                   (random-exercise-index (- (random len-files) compensate))
                   (starting-exercise-index 
                    (if (< random-exercise-index compensate)
                        (random (min compensate len-files))
                      random-exercise-index))
                   (excercise (nth starting-exercise-index files)))
              (find-file excercise))
            (let ((timer (run-with-timer 30 10 'slideview-next-file)))
              ;; Wait for user to come back.
              (read-event)
                  (type-break-catch-up-event)
              (cancel-timer timer)))
          (kill-buffer "*Slideview*"))
      (quit
       (read-event)
       (type-break-catch-up-event)
       (and (get-buffer "*Slideview*")
            (kill-buffer "*Slideview*")))))
  (add-to-list 'type-break-demo-functions 'type-break-demo-slideview)
  )

;;; Open files as root - quickly
(defcustom find-file-root-prefix "/sudoedit::"
"Tramp root prefix to use.")

(defun find-file-as-root ()
  "Like `ido-find-file, but automatically edit the file with
root-privileges (using tramp/sudo), if the file is not writable by
user."
  (interactive)
  (let ((file (ido-read-file-name "Edit as root: ")))
    (unless (file-writable-p file)
      (setq file (concat find-file-root-prefix file)))
    (find-file file)))
;; or some other keybinding...
;; (global-set-key (kbd "C-x F") 'djcb-find-file-as-root)

(defun find-current-as-root ()
  "Reopen current file as root"
  (interactive)
  (set-visited-file-name (concat find-file-root-prefix (buffer-file-name)))
  (setq buffer-read-only nil))

M-x diff-hl-mode
M-x diff-hl-set-reference-rev RET <revision>

(use-package org-agenda
  :defer 6
  :custom
  (org-agenda-diary-file "~/.emacs.d/diaries/calexport")
  (calendar-mark-diary-entries-flag t)
  (calendar-view-diary-initially-flag t)
  (alert-default-style 'libnotify)
  (appt-disp-window-function 'alert-for-appt)
  (org-agenda-include-diary t)
  (appt-delete-window-function (lambda ()))
  (org-agenda-clock-consistency-checks
   (quote
    (:max-duration "12:00" :min-duration 0 :max-gap "0:05" :gap-ok-around
                   ("4:00" "12:00")
                   :default-face
                   ((:background "DarkRed")
                    (:foreground "white"))
                   :overlap-face nil :gap-face nil :no-end-time-face nil :long-face nil :short-face nil)))
  (org-agenda-clockreport-parameter-plist (quote (:link t :maxlevel 2 :properties ("Effort"))))
  (org-agenda-start-with-clockreport-mode nil)
  :config
  ;; Rebuild the reminders everytime the agenda is displayed
  (add-hook 'org-agenda-finalize-hook (lambda () (org-agenda-to-appt t)))
  ;; Run once when Emacs starts
  (org-agenda-to-appt t)
  ;; Activate appointments so we get notifications
  (appt-activate t)
  ;; Add calendar, option 3  https://www.ict4g.net/adolfo/notes/emacs/emacs-caldav.html
  (setq diary-location "~/.emacs.d/diaries/")
  (add-hook 'diary-list-entries-hook 'diary-include-other-diary-files)
  (add-hook 'diary-mark-entries-hook 'diary-mark-included-diary-files)
  (setq calendars
        '(("calexport" . "https://example.com/owa/SECRET@example.com/SECRET/calendar.ics")))
  (defun getcal (url file)
    "Download ics file and add it to file"
    (let ((tmpfile (url-file-local-copy url)))
      (icalendar-import-file tmpfile file)
      ;; fixup %2B (+) from +49 phone numbers ;; TODO: report bug for icalendar-import-file
      (let ((unhexed (url-unhex-string (buffer-string))))
        (erase-buffer)
        (insert unhexed))
      ;; preserve previous calendar entries in case of network problems
      (when (string-blank-p (buffer-string)) (undo))
      (kill-buffer (car (last (split-string tmpfile "/"))))))
  (defun getcals ()
    "Load a set of ICS calendars into Emacs diary files"
    (interactive)
    (save-mark-and-excursion
      (save-window-excursion
        (with-silent-modifications
          (mapcar #'(lambda (x)
                    (let ((file (concat diary-location (car x)))
                          (url (cdr x)))
                      (message (concat "Loading " url " into " file))
                      (find-file file)
                      ;; (flush-lines "^[& ]") ;; if you import ical as non marking
                      (erase-buffer) ;; to avoid duplicating events
                      (getcal url file)))
                  calendars)))))
  (defun appt-reparse-diary-file ()
    "force reparsing the diary file"
    (appt-check t))
  (add-to-list 'midnight-hook 'getcals)
  (add-to-list 'midnight-hook 'appt-reparse-diary-file))

(setq use-dialog-box nil
      use-system-tooltips nil)

(custom-set-faces
 ;; show VCS additions more strongly.
 '(diff-hl-insert ((t (:inherit diff-added 
                       :background "#ccffcc"
                       :foreground "green4"))))
 ;; show the active window with color, because I
 ;; always had to look twice to search the focus.
 '(mode-line ((t (:background "light goldenrod"
                  :foreground "black"
                  :box (:line-width (1 . -1)
                  :style released-button)))))
 ;; show org-mode block start and end more strongly.
 '(org-block-begin-line ((t (:inherit org-meta-line
                             :background "wheat"))))
 '(org-block-end-line ((t (:inherit org-meta-line
                           :background "wheat"))))
 ;; highlight the region more strongly.
 '(region ((t (:extend t :background "cornsilk")))))

(use-package dumb-jump :ensure t :defer 10
  :custom
  (dumb-jump-rg-search-args '())
  :config
  (require 'xref)
  ;; Only use completing-read if you use vertical completion. I use ido, so I do not use it.
  ;; (setq xref-show-definitions-function #'xref-show-definitions-completing-read
  ;;       xref-show-xrefs-function       #'xref-show-definitions-completing-read)
  (defun find-definition-or-references ()
    (interactive)
    (let ((buffer-and-point (cons (buffer-name) (point)))
          (xref-prompt-for-identifier nil))
      (condition-case nil
          (call-interactively 'xref-find-definitions)
        (error
         (when (equal buffer-and-point (cons (buffer-name (window-buffer)) (point)))
           (call-interactively 'xref-find-references))))))
  ;; add proper typescript handling
  ;; thanks to https://github.com/amake/.emacs.d/commit/c4307e9605b71d2e603fde9ca4354cd60fac359f#diff-82c647c7e6a8e02d1b94a30268eb483ff5aadf926762a759fcd0f4c5850356bf
  (nconc dumb-jump-language-file-exts
         '((:language "typescript" :ext "ts" :agtype "ts" :rgtype nil)
           (:language "typescript" :ext "tsx" :agtype "ts" :rgtype "ts")))
  (nconc dumb-jump-language-comments
         '((:comment "//" :language "typescript")))
  (nconc dumb-jump-find-rules
         ;; Rules translated from link below, except where noted
         ;; https://github.com/jacktasia/dumb-jump/issues/97#issuecomment-346441412
         '((:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(export\\s+(abstract\\s+)?)?class\\s+JJJ\\b"
                  :tests ("class test" "export class test" "abstract class test"
                          "export abstract class test")
                  :not ("class testnot"))
           (:type "module" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(declare\\s+)?namespace\\s+JJJ\\b"
                  :tests ("declare namespace test" "namespace test")
                  :not ("declare testnot"))
           (:type "module" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(export\\s+)?module\\s+JJJ\\b"
                  :tests ("export module test" "module test")
                  :not ("module testnot"))
           (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(export\\s+)?(async\\s+)?function\\s+JJJ\\b"
                  :tests ("function test" "export function test" "export async function test"
                          "async function test")
                  :not ("function testnot"))
           (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "export\\s+(var|let|const)\\s+JJJ\\b"
                  :tests ("export var test" "let test" "const test")
                  :not ("var testnot"))
           (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(var|let|const)\\s+JJJ\\s*=\\s*function\\s*\\*?\\s*\\\(\\\)"
                  :tests ("var test = function ()" "let test = function()" "const test=function*()")
                  :not ("var testnot = function ()"))
           (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(export\\s+)?(public|protected|private)\\s+(static\\s+)?(abstract\\s+)?(((get|set)\\s+)|(async\\s+))?JJJ\\b"
                  :tests ("public test" "protected static test" "private abstract get test"
                          "export public static set test" "export protected abstract async test")
                  :not ("public testnot"))
           (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(export\\s+)?interface\\s+JJJ\\b"
                  :tests ("interface test" "export interface test")
                  :not ("interface testnot"))
           (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(export\\s+)?type\\s+JJJ\\b"
                  :tests ("type test" "export type test")
                  :not ("type testnot"))
           (:type "enum" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
                  :regex "(export\\s+)?enum\\s+JJJ\\b"
                  :tests ("enum test" "export enum test")
                  :not ("enum testnot"))))
           ;; Custom definition for public methods without "public" keyword.
           ;; Fragile! Requires brace on same line.
           ;; (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript"
           ;;        :regex "\\bJJJ\\s*\\(.*\\{"
           ;;        :tests ("test() {" "test(foo: bar) {")
           ;;        :not ("testnot() {"))))
  ;; understand types (this is non-standard for dumb-jump, but seems to work)
  (add-to-list 'dumb-jump-language-contexts '(:type "type" :language "typescript"
                                                    :left ": " :right ";\\|\)\\|,"))
  (add-to-list 'dumb-jump-language-contexts '(:type "type" :language "typescript"
                                                    :left "(type =|interface)"))
  ;; use dumb-jump as xref-searcher (no setup and fast)
  (add-hook 'xref-backend-functions #'dumb-jump-xref-activate)
  ;; use C-M-g as shortcut
  (define-key global-map (kbd "C-M-g") 'find-definition-or-references)
  (define-key dumb-jump-mode-map (kbd "C-M-g") 'find-definition-or-references)
  (define-key global-map (kbd "C-M-p") 'xref-pop-marker-stack)
  ;; setup CTRL-left click handling
  (defun jump-to-mouse-position (event &optional promote-to-region)
    (interactive "e\np")
    (mouse-set-point event promote-to-region)
    (find-definition-or-references))
  (global-unset-key [C-down-mouse-1])
  (define-key global-map [C-mouse-1] 'jump-to-mouse-position))

;; setup in ~/.emacs.d/init.el
(use-package flycheck-eglot :defer 30 :ensure t)
(use-package flycheck-pycheckers :defer 30 :ensure t)
(use-package flycheck-mypy :defer 30 :ensure t)
(use-package pyvenv :defer 30 :ensure t)
(use-package pyvenv-auto :defer 31 :ensure t)

;; lsp setup
(use-package eglot
  :defer 30
  :ensure t
  :hook ((python-mode . eglot-ensure) ;; start eglot for python
         (python-mode . flyspell-prog-mode) ;; spell checking
         (python-mode . hs-minor-mode) ;; collapse code
         (python-mode . flycheck-mode) ;; linter
         ;; tree-sitter version
         (python-ts-mode . eglot-ensure)
         (python-ts-mode . flyspell-prog-mode)
         (python-ts-mode . hs-minor-mode)
         (python-ts-mode . flycheck-mode)))

;; setup with use-package in ~/.emacs.d/init.el
;; sidebar
(use-package dired-sidebar
  :bind (("C-x C-n" . dired-sidebar-toggle-sidebar))
  :ensure t
  :defer 30
  :commands (dired-sidebar-toggle-sidebar)
  :custom
  (dired-sidebar-subtree-line-prefix "__")
  (dired-sidebar-theme 'vscode)
  (dired-sidebar-width 40) ;; for Python
  (dired-sidebar-use-term-integration t)
  :init
  (add-hook 'dired-sidebar-mode-hook
            (lambda ()
              (unless (file-remote-p default-directory)
                (auto-revert-mode))))
  :config
  (push 'toggle-window-split dired-sidebar-toggle-hidden-commands)
  (push 'rotate-windows dired-sidebar-toggle-hidden-commands))

;; open files in the project
(use-package projectile :ensure t :defer 1
  :config
  (projectile-mode)
  (define-key projectile-mode-map (kbd "C-c p") 'projectile-command-map)
  (define-key projectile-command-map (kbd "s") 'projectile-ripgrep)
  (define-key projectile-command-map (kbd "f") 'projectile-find-file)
  (add-to-list 'project-find-functions
    (lambda (x) (cons 'transient (projectile-project-root x))))
  :custom
  (projectile-switch-project-action 'projectile-find-file)
  ;; hide output from too long lines
  (ripgrep-arguments '("-M 256")))

(use-package ido
  :config
  (ido-mode 1))

(require 'ansi-color)
(defun display-ansi-colors ()
  (interactive)
  (ansi-color-apply-on-region (point-min) (point-max)))

(defun colorize-compilation-buffer ()
  "show shell colors in the compilation buffer"
  (read-only-mode -1)
  (ansi-color-apply-on-region compilation-filter-start (point))
  (read-only-mode))
(add-hook 'compilation-filter-hook 'colorize-compilation-buffer)

(defvar knowledge-base-filepath "~/emacs-knowledge-base/know.org" 
 "Path to the file to read and write the knowledge base")
(use-package helm-org-rifle :ensure t :defer 10 :after org-agenda
  :config
  (defun know()
    (interactive)
    (with-current-buffer (find-file knowledge-base-filepath)
      (helm-org-rifle)))
  (require 'org-capture) ;; for the templates
  (add-to-list 'org-capture-templates
                `("k" "knowlege base entry" entry
                  (file ,knowledge-base-filepath)
                 "" :clock-in t :clock-resume t)
                t))

(use-package autocrypt :ensure t
  :config
  (add-hook 'message-mode-hook #'autocrypt-mode)
  (defun autocrypt-import-known-keydata ()
    (interactive)
    "Import the key data of the current recipients into GPG so default message encrypting works."
    (dolist (account (autocrypt-list-recipients))
      (let ((keydata (autocrypt-generate-header account)))
        (when keydata
          (with-temp-buffer
            (insert keydata)
            (goto-char (point-min))
            (kill-line) ;; first line of the header is metadata
            (insert "-----BEGIN PGP PUBLIC KEY BLOCK-----\n")
            (goto-char (point-max))
            (insert "\n-----End PGP PUBLIC KEY BLOCK-----\n")
            (epa-import-keys-region (point-min) (point-max)))))))
  (add-hook 'mu4e-compose-post-hook #'autocrypt-import-known-keydata))