;; Single directory
;; (add-to-list 'load-path "~/.guix-profile/share/emacs/site-lisp/mu4e")

;; All sub directories
(let ((default-directory  "~/.guix-profile/share/emacs/site-lisp/"))
  (normal-top-level-add-subdirs-to-load-path))

(require 'org-auto-tangle)

(add-hook 'org-mode-hook 'org-auto-tangle-mode)

(require 'package)

(setq package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
                         ("melpa" . "https://melpa.org/packages/")))

(defvar my-packages '(ac-cider
                      ace-window
                      ac-js2
                      ag
                      atomic-chrome
                      auto-complete
                      beacon
                      bicycle
                      browse-kill-ring
                      cider
                      clj-refactor
                      clojure-mode
                      coffee-mode
                      counsel-jq
                      comment-tags
                      darktooth-theme
                      dired-narrow
                      diminish
                      dumb-jump
                      edit-indirect
                      editorconfig
                      elfeed
                      elfeed-goodies
                      enh-ruby-mode
                      erc-image
                      evil
                      evil-escape
                      evil-leader
                      evil-mc
                      evil-numbers
                      evil-surround
                      exec-path-from-shell
                      forge
                      flycheck
                      flycheck-flow
                      flycheck-grammarly
                      flycheck-package
                      hcl-mode
                      hide-mode-line
                      impatient-mode
                      ivy counsel swiper
                      json-mode
                      js2-mode
                      js2-refactor
                      js-comint
                      ledger-mode
                      magit
                      magit-delta
                      markdown-mode
                      org-ai
                      package-lint
                      pdf-tools
                      projectile
                      rainbow-mode
                      rjsx-mode
                      ob-restclient
                      restclient
                      robe
                      sass-mode
                      smex
                      synosaurus
                      tide
                      visual-fill-column
                      web-mode
                      which-key
                      writegood-mode
                      writeroom-mode
                      quelpa
                      yaml-mode
                      zenburn-theme))

(dolist (p my-packages)
  (unless (package-installed-p p)
    (package-refresh-contents)
    (package-install p))
  (add-to-list 'package-selected-packages p))

(if (string< emacs-version
         "26.3")
      (setq gnutls-algorithm-priority "NORMAL:-VERS-TLS1.3"))

(setq gc-cons-threshold 20000000)

(setq make-backup-files nil)

(setq large-file-warning-threshold 200000000)

(setq backup-directory-alist
      `((".*" . ,temporary-file-directory)))
(setq auto-save-file-name-transforms
      `((".*" ,temporary-file-directory t)))

(setq vc-follow-symlinks t)

(setq sentence-end-double-space nil)

(setq confirm-kill-emacs 'y-or-n-p)

(put 'dired-find-alternate-file 'disabled nil)

(setq-default dired-listing-switches "-alh")

(setq dired-recursive-copies 'always)

(require 'dired)
(define-key dired-mode-map (kbd "/") 'dired-narrow-fuzzy)

(fset 'yes-or-no-p 'y-or-n-p)

(global-auto-revert-mode t)

(defun zoom-in ()
  (interactive)
  (let ((x (+ (face-attribute 'default :height)
              10)))
    (set-face-attribute 'default nil :height x)))

(defun zoom-out ()
  (interactive)
  (let ((x (- (face-attribute 'default :height)
              10)))
    (set-face-attribute 'default nil :height x)))

(define-key global-map (kbd "C-1") 'zoom-in)
(define-key global-map (kbd "C-0") 'zoom-out)

(setq inhibit-splash-screen t)
(setq inhibit-startup-message t)

(display-time-mode t)

(tool-bar-mode 0)

(add-hook 'org-mode-hook 'auto-fill-mode)

(add-hook 'visual-line-mode-hook #'visual-fill-column-mode)

;; Don't do it at this time, it's only enabled for some modes explicitly.
;; (add-hook 'text-mode-hook 'visual-line-mode)

(add-hook 'visual-line-mode-hook #'adaptive-wrap-prefix-mode)

(put 'narrow-to-region 'disabled nil)

(scroll-bar-mode -1)

(setq save-place-file "~/.emacs.d/saveplace")
(if (version<= emacs-version "25.1")
    (progn
      (setq-default save-place t)
      (require 'saveplace))
  (save-place-mode 1))

;; Safeguard, so this only runs on Linux (or MacOS)
(when (memq window-system '(mac ns x))
  (exec-path-from-shell-initialize))

(global-set-key (kbd "M-o") 'ace-window)

(when (fboundp 'winner-mode)
  (winner-mode 1))

(setq visible-bell t)

(setq ange-ftp-try-passive-mode t)

(add-hook 'eww-mode-hook 'scroll-lock-mode)

(setq custom-file "~/.emacs.d/custom-settings.el")
(load custom-file t)

(setq-default bidi-paragraph-direction 'left-to-right)

(if (version<= "27.1" emacs-version)
    (setq bidi-inhibit-bpa t))

(if (version<= "27.1" emacs-version)
    (global-so-long-mode 1))

(setq native-comp-async-report-warnings-errors nil)

(load "~/.emacs.d/dict")

(defun kill-other-buffers ()
  "Kill all other buffers."
  (interactive)
  (mapc 'kill-buffer (delq (current-buffer) (buffer-list))))

(defun kill-dired-buffers ()
  "Kill all open dired buffers."
  (interactive)
  (mapc (lambda (buffer)
          (when (eq 'dired-mode (buffer-local-value 'major-mode buffer))
            (kill-buffer buffer)))
        (buffer-list)))

(defun encode-html (start end)
  "Encodes HTML entities; works great in Visual Mode (START END)."
  (interactive "r")
  (save-excursion
    (save-restriction
      (narrow-to-region start end)
      (goto-char (point-min))
      (replace-string "&" "&")
      (goto-char (point-min))
      (replace-string "<" "&lt;")
      (goto-char (point-min))
      (replace-string ">" "&gt;"))))

(defun md-compile ()
  "Compiles the currently loaded markdown file using pandoc into a PDF"
  (interactive)
  (save-buffer)
  (shell-command (concat "pandoc " (buffer-file-name) " -o "
                         (replace-regexp-in-string "md" "pdf" (buffer-file-name)))))

(defun update-other-buffer ()
  (interactive)
  (other-window 1)
  (revert-buffer nil t)
  (other-window -1))

(defun md-compile-and-update-other-buffer ()
  "Has as a premise that it's run from a markdown-mode buffer and the
   other buffer already has the PDF open"
  (interactive)
  (md-compile)
  (update-other-buffer))

(defun latex-compile-and-update-other-buffer ()
  "Has as a premise that it's run from a latex-mode buffer and the
   other buffer already has the PDF open"
  (interactive)
  (save-buffer)
  (shell-command (concat "pdflatex " (buffer-file-name)))
  (switch-to-buffer (other-buffer))
  (kill-buffer)
  (update-other-buffer))

(defun org-compile-beamer-and-update-other-buffer ()
  "Has as a premise that it's run from an org-mode buffer and the
   other buffer already has the PDF open"
  (interactive)
  (org-beamer-export-to-pdf)
  (update-other-buffer))

(defun org-compile-latex-and-update-other-buffer ()
  "Has as a premise that it's run from an org-mode buffer and the
   other buffer already has the PDF open"
  (interactive)
  (org-latex-export-to-pdf)
  (update-other-buffer))

(eval-after-load 'latex-mode
  '(define-key latex-mode-map (kbd "C-c r") 'latex-compile-and-update-other-buffer))

(define-key org-mode-map (kbd "C-c lr") 'org-compile-latex-and-update-other-buffer)
(define-key org-mode-map (kbd "C-c br") 'org-compile-beamer-and-update-other-buffer)

(eval-after-load 'markdown-mode
  '(define-key markdown-mode-map (kbd "C-c r") 'md-compile-and-update-other-buffer))

(define-key key-translation-map [dead-diaeresis]
  (lookup-key key-translation-map "\C-x8\""))
(define-key isearch-mode-map [dead-diaeresis] nil)
(global-set-key (kbd "M-u")
                (lookup-key key-translation-map "\C-x8\""))

(defun generate-password-non-interactive ()
   (string-trim (shell-command-to-string "pwgen -A 24")))

(defun generate-password ()
  "Generates and inserts a new password"
  (interactive)
  (insert
   (shell-command-to-string
    (concat "pwgen -A " (read-string "Length: " "24") " 1"))))

(fset 'copy-password-to-clipboard
   [?\C-s ?P ?a ?s ?s ?w ?o ?r ?d ?: return ?w ?v ?$ ?y C-up C-up C-up tab])

(defun passwords ()
  "Open main 'passwords' file."
  (interactive)
  (find-file (concat org-directory "vault/primary.org.gpg")))

(defun server-shutdown ()
  "Save buffers, Quit, and Shutdown (kill) server"
  (interactive)
  (save-some-buffers)
  (kill-emacs))

(defmacro measure-time (&rest body)
  "Measure the time it takes to evaluate BODY."
  `(let ((time (current-time)))
     ,@body
     (message "%.06f" (float-time (time-since time)))))

(defun ph/sudo-file-name (filename)
  "Prepend '/sudo:root@`system-name`:' to FILENAME if appropriate.
This is, when it doesn't already have a sudo-prefix."
  (if (not (or (string-prefix-p "/sudo:root@localhost:"
                                filename)
               (string-prefix-p (format "/sudo:root@%s:" system-name)
                                filename)))
      (format "/sudo:root@%s:%s" system-name filename)
    filename))

(defun ph/sudo-save-buffer ()
  "Save FILENAME with sudo if the user approves."
  (interactive)
  (when buffer-file-name
    (let ((file (ph/sudo-file-name buffer-file-name)))
      (if (yes-or-no-p (format "Save file as %s ? " file))
          (write-file file)))))

(advice-add 'save-buffer :around
            '(lambda (fn &rest args)
               (when (or (not (buffer-file-name))
                         (not (buffer-modified-p))
                         (file-writable-p (buffer-file-name))
                         (not (ph/sudo-save-buffer)))
                 (call-interactively fn args))))

(defadvice server-visit-files (before parse-numbers-in-lines (files proc &optional nowait) activate)
  "Open file with emacsclient with cursors positioned on requested line.
Most of console-based utilities prints filename in format
'filename:linenumber'.  So you may wish to open filename in that format.
Just call:
  emacsclient filename:linenumber
and file 'filename' will be opened and cursor set on line 'linenumber'"
  (ad-set-arg 0
              (mapcar (lambda (fn)
                        (let ((name (car fn)))
                          (if (string-match "^\\(.*?\\):\\([0-9]+\\)\\(?::\\([0-9]+\\)\\)?$" name)
                              (cons
                               (match-string 1 name)
                               (cons (string-to-number (match-string 2 name))
                                     (string-to-number (or (match-string 3 name) ""))))
                            fn))) files)))

;; https://www.reddit.com/r/emacs/comments/idz35e/emacs_27_can_take_svg_screenshots_of_itself/
(defun screenshot-svg ()
  "Save a screenshot of the current frame as an SVG image.
Saves to a temp file and puts the filename in the kill ring."
  (interactive)
  (let* ((filename (make-temp-file "Emacs" nil ".svg"))
         (data (x-export-frames nil 'svg)))
    (with-temp-file filename
      (insert data))
    (kill-new filename)
    (message filename)))

(setq search-default-mode #'char-fold-to-regexp)

(defun move-line-up ()
  "Move up the current line."
  (interactive)
  (transpose-lines 1)
  (forward-line -2)
  (indent-according-to-mode))

(defun move-line-down ()
  "Move down the current line."
  (interactive)
  (forward-line 1)
  (transpose-lines 1)
  (forward-line -1)
  (indent-according-to-mode))

(global-set-key (kbd "M-<down>") 'move-line-down)
(global-set-key (kbd "M-<up>") 'move-line-up)

(defun count-lines-with-expression (s exp)
  "Count the number of lines in the string S that contain the regular expression EXP."
  (let ((count 0))
    (mapc (lambda (line)
            (when (string-match-p exp line)
              (setq count (+ 1 count))))
          (split-string s "\n"))
    count))


(defun productivity-of-the-day ()
  (seq-reduce
   (lambda (acc it)
     (let* ((folder (file-name-directory it))
            (file (file-name-nondirectory it))
            (base-cmd (concat "cd "
                              folder
                              "; git log --since=midnight -p "
                              file
                              "| grep TODO"))
            (changed (shell-command-to-string base-cmd))
            (added (count-lines-with-expression changed "^\\+"))
            (removed (count-lines-with-expression changed "^\\-")))
       (cons (+ (car acc) added)
             (- (cdr acc) removed))))
   org-agenda-files
   '(0 . 0)))

(beacon-mode 1)

(require 'browse-kill-ring)
(setq browse-kill-ring-highlight-inserted-item t
      browse-kill-ring-highlight-current-entry nil
      browse-kill-ring-show-preview t)
(define-key browse-kill-ring-mode-map (kbd "j") 'browse-kill-ring-forward)
(define-key browse-kill-ring-mode-map (kbd "k") 'browse-kill-ring-previous)

(evil-mode t)
;; Enable "M-x" in evil mode
(global-set-key (kbd "M-x") 'execute-extended-command)

(global-evil-leader-mode)
(evil-leader/set-leader ",")
(evil-leader/set-key
  "w" 'basic-save-buffer
  "s" 'flyspell-buffer
  "b" 'evil-buffer
  "q" 'evil-quit)

(require 'evil-surround)
(global-evil-surround-mode 1)

(global-evil-mc-mode  1)

(define-key evil-normal-state-map (kbd "{") 'evil-next-buffer)
(define-key evil-normal-state-map (kbd "}") 'evil-prev-buffer)

(global-set-key (kbd "C-=") 'evil-numbers/inc-at-pt)
(global-set-key (kbd "C--") 'evil-numbers/dec-at-pt)
(define-key evil-normal-state-map (kbd "C-=") 'evil-numbers/inc-at-pt)
(define-key evil-normal-state-map (kbd "C--") 'evil-numbers/dec-at-pt)

(define-key evil-normal-state-map (kbd "j") 'evil-next-visual-line)
(define-key evil-normal-state-map (kbd "k") 'evil-previous-visual-line)

(define-key evil-insert-state-map (kbd "C-v") 'evil-visual-paste)

(mapc (lambda (mode)
        (evil-set-initial-state mode 'emacs)) '(elfeed-show-mode
                                                elfeed-search-mode
                                                forge-pullreq-list-mode
                                                forge-topic-list-mode
                                                dired-mode
                                                tide-references-mode
                                                image-dired-mode
                                                image-dired-thumbnail-mode
                                                eww-mode))

(defadvice cider--debug-mode (after toggle-evil activate)
  "Turn off `evil-local-mode' when enabling
`cider--debug-mode', and turn it back on when disabling
`cider--debug-mode'."
  (evil-local-mode (if cider--debug-mode -1 1)))

(define-key evil-normal-state-map (kbd "M-.") nil)
(define-key evil-normal-state-map (kbd "M-,") nil)

(define-key global-map (kbd "M-l") nil)
(define-key evil-insert-state-map (kbd "M-l M-l") nil)

(define-key global-map (kbd "M-k") nil)
(define-key evil-insert-state-map (kbd "M-k M-k") nil)

(define-key global-map (kbd "<tab>") nil)
(define-key evil-insert-state-map (kbd "<tab>") nil)
(evil-define-key 'normal org-mode-map (kbd "<tab>") #'org-cycle)

(setq evil-ex-visual-char-range t)

(setq-default evil-escape-delay 0.2)
(setq-default evil-escape-key-sequence "jk")
(evil-escape-mode)

(add-hook 'org-mode-hook 'which-key-mode)
(add-hook 'cider-mode-hook 'which-key-mode)

(setq which-key-allow-evil-operators t)
(setq which-key-show-operator-state-maps t)

(ac-config-default)

(setq-default tab-width 2)

(setq-default tab-width 2 indent-tabs-mode nil)

(setq-default indent-tabs-mode nil)

(setq js-indent-level 2)

(setq coffee-tab-width 2)

(setq python-indent 2)

(setq css-indent-offset 2)

(add-hook 'sh-mode-hook
          (lambda ()
            (setq sh-basic-offset 2
                  sh-indentation 2)))

(setq web-mode-markup-indent-offset 2)

(add-hook 'after-init-hook #'global-flycheck-mode)

(eval-after-load 'flycheck
  '(flycheck-package-setup))

;; (require 'flycheck-grammarly)

(define-key global-map (kbd "RET") 'newline-and-indent)

(show-paren-mode t)

(add-hook 'before-save-hook '(lambda()
                               (when (not (or (derived-mode-p 'markdown-mode)
                                              (derived-mode-p 'org-mode)))
                                (delete-trailing-whitespace))))

(add-hook 'prog-mode-hook #'hs-minor-mode)

(add-hook 'prog-mode-hook #'outline-minor-mode)

;; Org mode style keybindings
(define-key outline-minor-mode-map (kbd "C-<return>") 'outline-insert-heading)
(define-key outline-minor-mode-map (kbd "M-S-<right>") 'outline-demote)
(define-key outline-minor-mode-map (kbd "M-S-<left>") 'outline-promote)
(define-key outline-minor-mode-map (kbd "C-c C-n") 'outline-next-visible-heading)
(define-key outline-minor-mode-map (kbd "C-c C-p") 'outline-previous-visible-heading)

(define-key outline-minor-mode-map (kbd "C-<tab>") 'bicycle-cycle)
(define-key outline-minor-mode-map (kbd "<backtab>") 'bicycle-cycle-global)

(require 'foldout)
(define-key outline-minor-mode-map (kbd "C-x n s") 'foldout-zoom-subtree)
(define-key outline-minor-mode-map (kbd "C-x n w") 'foldout-exit-fold)

(add-hook 'prog-mode-hook '(lambda ()
                             (if (version<= emacs-version "26.0.50")
                                 (linum-mode)
                               (display-line-numbers-mode))))

(defun indent-buffer ()
  (interactive)
  (save-excursion
    (indent-region (point-min) (point-max) nil)))

(setq ruby-indent-level 2)
;; scss-mode blocks Emacs when opening bigger files, so open them with css-mode
(add-to-list 'auto-mode-alist '("\\.scss?\\'" . css-mode))

(add-to-list 'auto-mode-alist '("\\.rb?\\'" . enh-ruby-mode))
(add-to-list 'auto-mode-alist '("\\.rake?\\'" . enh-ruby-mode))

(add-hook 'enh-ruby-mode-hook 'robe-mode)
(add-hook 'robe-mode-hook 'ac-robe-setup)
(add-to-list 'auto-mode-alist '("\\.erb?\\'" . robe-mode))

(add-hook 'enh-ruby-mode-hook 'auto-complete-mode)

(add-hook 'enh-ruby-mode-hook
          (lambda ()
            (local-set-key (kbd "C-x C-e") 'ruby-send-line)))

(add-hook 'cider-mode-hook (lambda ()
  (define-key cider-mode-map (kbd "C-c C-p") nil)))

(require 'ac-cider)
;;(setq ac-quick-help-delay 0.5)
(add-hook 'cider-mode-hook 'ac-flyspell-workaround)
(add-hook 'cider-mode-hook 'ac-cider-setup)
(add-hook 'cider-repl-mode-hook 'ac-cider-setup)
(eval-after-load "auto-complete"
  '(progn
     (add-to-list 'ac-modes 'cider-mode)
     (add-to-list 'ac-modes 'cider-repl-mode)))

(setq cider-repl-pop-to-buffer-on-connect nil)

(require 'clj-refactor)
(add-hook 'clojure-mode-hook
          (lambda ()
            (clj-refactor-mode 1)
            (setq cljr-warn-on-eval nil)
            (yas-minor-mode 1) ; for adding require/use/import statements
            ;; This choice of keybinding leaves cider-macroexpand-1 unbound
            (cljr-add-keybindings-with-prefix "C-c C-m")))

(defun ok-cider-reload-integrant ()
  (interactive)
  (require 'seq)
  (save-buffer)
  (let ((cider-buffer (first (seq-filter '(lambda (buf)
                         (string-match "cider-repl" buf))
                                         (mapcar 'buffer-name (buffer-list))))))
    (if cider-buffer
        (progn
          (switch-to-buffer cider-buffer)
          (insert "(in-ns 'dev)(integrant.repl/reset)")
          (cider-repl-return)
          (switch-to-buffer (other-buffer)))
      (message "No Cider buffer!"))))

(define-key
  clojure-mode-map
  (kbd "C-c r")
  'ok-cider-reload-integrant)

(require 'rjsx-mode)
(define-key rjsx-mode-map (kbd "C-c C-r") 'tide-rename-symbol)
(define-key rjsx-mode-map (kbd "C-c C-d") 'tide-documentation-at-point)

(defun setup-tide-mode ()
  (interactive)
  ;; For bigger JS projects and intense tasks like =tide=references=
  ;; the default of 2s will time out
  (setq tide-sync-request-timeout 10)
  (tide-setup)
  ;; Increase sync request timeout for bigger projects
  (flycheck-mode +1)
  (setq flycheck-check-syntax-automatically '(save mode-enabled))
  (eldoc-mode +1)
  (tide-hl-identifier-mode +1))

(add-hook 'rjsx-mode-hook #'setup-tide-mode)

(require 'js-comint)

(add-hook 'rjsx-mode-hook
          (lambda ()
            (local-set-key (kbd "C-x C-e") 'js-send-last-sexp)
            (local-set-key (kbd "C-M-x") 'js-send-last-sexp-and-go)
            (local-set-key (kbd "C-c b") 'js-send-buffer)
            (local-set-key (kbd "C-c C-b") 'js-send-buffer-and-go)
            (local-set-key (kbd "C-c l") 'js-load-file-and-go)))

(require 'flycheck-flow)
(add-hook 'javascript-mode-hook 'flycheck-mode)

(add-to-list 'auto-mode-alist '("components\\/.*\\.js\\'" . rjsx-mode))

(add-to-list 'auto-mode-alist '("\\.js\\'" . rjsx-mode))
(add-hook 'js-mode-hook 'js2-minor-mode)
(setq js2-highlight-level 3)
(setq js-indent-level 2)
;; Semicolons are optional in JS, do not warn about them missing
(setq js2-strict-missing-semi-warning nil)

(add-hook 'prog-mode-hook 'rainbow-mode)

(add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode))
;; Ruby Templates
(add-to-list 'auto-mode-alist '("\\.erb?\\'" . web-mode))
;; Handlebars
(add-to-list 'auto-mode-alist '("\\.hbs?\\'" . web-mode))
;; JSON
(add-to-list 'auto-mode-alist '("\\.json?\\'" . web-mode))

(setq web-mode-enable-current-element-highlight t)
(setq web-mode-ac-sources-alist
  '(("html" . (ac-source-words-in-buffer ac-source-abbrev))))

(add-to-list 'auto-mode-alist '("presentation.html" . markdown-mode))

(defun reload-chromium ()
  (when enable-browser-reloading
    (shell-command-to-string "reload_chromium.sh")))

(defun browser-reloading-mode ()
  "Finds the open chromium session and reloads the tab"
  (interactive)
  ;; When set, disable the local binding and therefore disable the mode
  (if enable-browser-reloading
      (setq enable-browser-reloading nil)
    ;; Otherwise create a local var and set it to True
    (progn
      (make-local-variable 'enable-browser-reloading)
      (setq enable-browser-reloading t))))

;; By default, disable the guard against using `reload-chromium`
(setq enable-browser-reloading nil)
(add-hook 'after-save-hook #'reload-chromium)

(require 'yaml-mode)
(add-to-list 'auto-mode-alist '("\\.yml$" . yaml-mode))
(add-hook 'yaml-mode-hook 'visual-line-mode)

(add-hook 'markdown-mode-hook 'flyspell-mode)
(add-hook 'markdown-mode-hook 'outline-minor-mode)

(add-hook 'markdown-mode-hook 'visual-line-mode)

(global-set-key (kbd "C-x g") 'magit-status)

(setq magit-commit-arguments (quote ("--gpg-sign=137099B38E1FC0E9")))

(add-hook 'with-editor-mode-hook 'evil-normal-state)

(with-eval-after-load 'magit
  (require 'forge))

(with-eval-after-load 'forge
  (add-to-list 'forge-alist
               '("gitlab.200ok.ch"
                 "gitlab.200ok.ch/api/v4"
                 "gitlab.200ok.ch"
                 forge-gitlab-repository))
  (add-to-list 'forge-alist
               '("gitlab.switch.ch"
                 "gitlab.switch.ch/api/v4"
                 "gitlab.switch.ch"
                 forge-gitlab-repository)))

(with-eval-after-load 'magit
  (magit-add-section-hook 'magit-status-sections-hook 'forge-insert-assigned-issues   nil t)
  (magit-add-section-hook 'magit-status-sections-hook 'forge-insert-assigned-pullreqs   nil t))

(add-hook 'magit-mode-hook (lambda () (magit-delta-mode +1)))

(setq magit-delta-delta-args
  '("--24-bit-color" "always"
    "--features" "magit-delta"
    "--color-only"))

(projectile-mode +1)
(define-key projectile-mode-map (kbd "C-c p") 'projectile-command-map)

(defadvice projectile-project-root (around ignore-remote first activate)
    (unless (file-remote-p default-directory) ad-do-it))

(dumb-jump-mode)
(setq dumb-jump-selector 'ivy)

(defun autoformat ()
  "Automatically format current buffer."
  (interactive)

  (if (derived-mode-p 'clojure-mode)
      (autoformat-clojure-function)
    (let ((eslint-path (concat (projectile-project-root)
                               ".eslintrc.yml"))) ; could be .json or .yml
      (autoformat-with
       (cond ((derived-mode-p 'web-mode) 'autoformat-html-command)
             ((derived-mode-p 'css-mode) 'autoformat-css-command)
             ((derived-mode-p 'nxml-mode) 'autoformat-xml-command)
             ((derived-mode-p 'json-mode) 'autoformat-json-command)
             ((derived-mode-p 'sass-mode) 'autoformat-sass-command)
             ((derived-mode-p 'yaml-mode) 'autoformat-yaml-command)
             ((derived-mode-p 'enh-ruby-mode) 'autoformat-ruby-command)
             ;; JS projects with eslint config
             ((and (file-exists-p eslint-path)
                   (derived-mode-p 'js2-mode))
              'autoformat-prettier-eslint-command)
             ((derived-mode-p 'js2-mode) 'autoformat-javascript-command))))))

(defun autoformat-with (strategy)
  "Automatically format current buffer using STRATEGY."
  (let ((p (point))
        (s (window-start)))
    ;; Remember the current position
    (save-mark-and-excursion
      ;; Call prettier-eslint binary with the contents of the current
      ;; buffer
      (shell-command-on-region
       (point-min) (point-max)
       (funcall strategy)
       ;; Write into a temporary buffer
       (get-buffer-create "*Temp autoformat buffer*")
       ;; Replace the current buffer with the output of
       ;; the =autoformat strategy= output
       t
       ;; If the =autoformat strategy= returns an error, show it in a
       ;; separate error buffer
       (get-buffer-create "*replace-errors*")
       ;; Automatically show error buffer
       t))
    ;; Return to the previous point and scrolling position (the point
    ;; was lost, because the whole buffer got replaced.
    (set-window-start (selected-window) s)
    (goto-char p)))

(defun autoformat-clojure-function ()
  "Cider function to format Clojure buffer."
  (indent-buffer)
  ;; (cider-format-buffer)
  )

(defun autoformat-ruby-command ()
  "CLI tool to format Ruby."
  "prettier --parser ruby")

(defun autoformat-javascript-command ()
  "CLI tool to format Javascript."
  "prettier --parser babel")

(defun autoformat-html-command ()
  "CLI tool to format HTML."
  "prettier --parser html")

(defun autoformat-css-command ()
  "CLI tool to format CSS."
  "prettier --parser css")

(defun autoformat-xml-command ()
  "CLI tool to format XML."
  "xmllint -format -")

(defun autoformat-sass-command ()
  "CLI tool to format SASS."
  "prettier --parser sass")

(defun autoformat-json-command ()
  "CLI tool to format JSON."
  "prettier --parser json")

(defun autoformat-yaml-command ()
  "CLI tool to format YAML."
  "prettier --parser yaml")

(defun autoformat-prettier-eslint-command ()
  "CLI tool to format Javascript with .eslintrc.json configuration."
  (concat "npx prettier-eslint  --stdin --eslint-config-path="
          ;; Hand over the path of the current projec
          (concat
           (projectile-project-root)
           ".eslintrc.yml")
           " --stdin-filepath="
           (buffer-file-name)
          " --parser babel"))

(setq ok-autoformat-modes (list 'web-mode
                'css-mode
                'json-mode
                'clojure-mode
                'sass-mode
                'enh-ruby-mode
                'yaml-mode
                'js2-mode
                'rjsx-mode))

(dolist (mode ok-autoformat-modes)
  (evil-leader/set-key-for-mode mode "f" 'autoformat))

;; Define list of projects to autoformat
(setq ok-autoformat-projects (list "src/200ok/organice"))

(add-hook 'before-save-hook
          '(lambda()
             ;; Check if the current directory matches the list of
             ;; projects that are to be autoformatted.
             (if (seq-some '(lambda (e)
                              (numberp e))
                           (mapcar '(lambda (dir)
                                      (string-match dir (projectile-project-root)))
                                   ok-autoformat-projects) )
                 (when (or
                        (derived-mode-p 'js2-mode)
                        (derived-mode-p 'css-mode)
                        (derived-mode-p 'sass-mode)
                        (derived-mode-p 'yaml-mode))
                   (autoformat)))))

(editorconfig-mode 1)

(add-to-list 'auto-mode-alist '("\\.tf" . hcl-mode))

(add-to-list 'auto-mode-alist '("\\.drl\\'" . java-mode))

(quelpa '(whisper :fetcher git :url "https://github.com/natrys/whisper.el.git"))

(setq whisper-install-directory "~/src"
      whisper-model "base-q8_0"
      whisper-language "auto"
      whisper-use-threads 10
      whisper-translate nil)

(define-key global-map (kbd "C-x R") 'whisper-run)

(setq org-directory "~/Dropbox/org/")

(setq org-image-actual-width 720)

(setq org-list-allow-alphabetical t)

(setq org-deadline-warning-days 3)

(require 'org)

; languages for org-babel support
(org-babel-do-load-languages
 'org-babel-load-languages
 '(
   (shell . t)
   (dot . t)
   (js . t)
   (ruby . t)
   ))

(add-hook 'org-mode-hook 'auto-fill-mode)
(add-hook 'org-mode-hook 'flyspell-mode)

(evil-leader/set-key
  "a" 'org-archive-subtree-default)

;; Allow =pdflatex= to use shell-commands. This will allow it to use
;; =pygments= as syntax highlighter for exports to PDF.
(setq org-latex-pdf-process
      '("pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"
        "pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"
        "pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"))
;;  Alternatively use =xelatex=. Required for documents where I want to use ttf fonts.
;;(setq org-latex-pdf-process
;;      '("xelatex -shell-escape -interaction nonstopmode -output-directory %o %f"
;;        "xelatex -shell-escape -interaction nonstopmode -output-directory %o %f"
;;        "xelatex -shell-escape -interaction nonstopmode -output-directory %o %f"))

;; Include =minted= package for LaTeX exports
(add-to-list 'org-latex-packages-alist '("" "minted"))
(setq org-latex-listings 'minted)

;; Don’t ask every time when executing a code block.
(setq org-confirm-babel-evaluate nil)

(setq org-imenu-depth 6)

(defun ok-imenu-show-entry ()
  "Reveal content of header."
  (cond
   ((and (eq major-mode 'org-mode)
         (org-at-heading-p))
    (org-show-entry)
    (org-reveal t))
   ((bound-and-true-p outline-minor-mode)
    (outline-show-entry))))

(add-hook 'imenu-after-jump-hook 'ok-imenu-show-entry)

(require 'ox-latex)
(add-to-list 'org-latex-classes
             '("scrartcl"
               "\\documentclass{scrartcl}"
               ("\\section{%s}" . "\\section*{%s}")))

(require 'ox-latex)
(add-to-list 'org-latex-classes
	     '("tuftehandout"
	       "\\documentclass{tufte-handout}
\\usepackage{color}
\\usepackage{amssymb}
\\usepackage{amsmath}
\\usepackage{gensymb}
\\usepackage{nicefrac}
\\usepackage{units}"
	       ("\\section{%s}" . "\\section*{%s}")
	       ("\\subsection{%s}" . "\\subsection*{%s}")
	       ("\\paragraph{%s}" . "\\paragraph*{%s}")
	       ("\\subparagraph{%s}" . "\\subparagraph*{%s}")))

(setq org-tags-column -100)

;; Set org-capture inbox
(setq org-default-notes-file (concat org-directory "inbox.org"))
(define-key global-map "\C-cc" 'org-capture)

(setq things-file (expand-file-name "things.org" org-directory))
(setq reference-file (expand-file-name "reference.org" org-directory))
(setq media-file (expand-file-name "media.org" org-directory))

(defun get-domainname (address)
  "Extract TLD (without country) from ADDRESS.
Example: Return '200ok' from '[email protected]'."
  (replace-regexp-in-string
   "\-" "_"
   (nth 0
        (split-string (nth 1 (split-string address "@"))
                      "\\."))))

(defun from-name (fromname fromaddress from)
  "Return the first non-empty match for FROMNAME FROMADDRESS and FROM."
  (nth 0
       (seq-filter '(lambda (s)
                      (not (string-empty-p s)))
                   (list fromname fromaddress from))))

(setq org-capture-templates
      '(("t" "Todo" entry (file+olp things-file "Inbox" "Tasks")
         "* TODO %?\n  %U\n  %i\n  %a")
         ("w" "Waiting" entry (file+olp things-file "Waiting")
         "* WAITING %?\n  %U\n  %i\n  %a")
         ;; Creates an expense line for the date of the mail, prompts
         ;; for the amount and currency
         ("e" "Expense" table-line (file+olp things-file "Inbox" "Expenses")
          "|%(org-insert-time-stamp (org-read-date nil t \"%:date\") nil t) | %(from-name \"%:fromname\" \"%:fromaddress\" \"%:from\")| [[%:link][Mail]] | %^{amount} | %^{currency|usd|chf|eur} | | | %^{scope|200ok-alain|200ok-joint|lambda} |")
        ("m" "Mail" entry (file+olp things-file "Inbox" "Mails")
         ;; Creates "* TODO <2019-05-01 Wed> FromName [[mu4e:msgid:uuid][MessageSubject]] :200ok:
         ;; Therefore Emails can be properly:
         ;;   - Used as tasks
         ;;   - Attributed tags
         ;;   - Ordered by priority
         ;;   - Scheduled
         ;;   - etc
         "* TODO %(org-insert-time-stamp (org-read-date nil t \"%:date\") nil t) %(from-name \"%:fromname\" \"%:fromaddress\" \"%:from\") %a \t :%(get-domainname \"%:toaddress\"):")
        ("d" "Daily focus" plain (file+olp things-file "Inbox" "Daily")
         (file "~/.emacs.d/org-templates/daily_focus.org"))
        ("M" "Meeting minutes" plain (file+olp things-file "Inbox" "Tasks")
         (file "~/.emacs.d/org-templates/minutes.org"))
        ("s" "Code Snippet" entry (file+headline "~/src/200ok/knowledge/README.org" "Snippets")
         ;; Prompt for tag and language
         "* %?\t%^g\n#+BEGIN_SRC %^{language}\n%i\n#+END_SRC")
        ("S" "Shopping" entry (file+olp "~/Dropbox/org/shared_with_monika/shared_alain_and_monika.org" "Shopping")
         "* TODO %?\n  %U\n  %i\n  %a")
        ("l" "Logbook entry" entry (file+olp+datetree reference-file "Logbook")
         "* %?\n  %U\n  %i\n  %a")
        ("p" "password" entry (file+headline "~/Dropbox/org/vault/primary.org.gpg" "Passwords")
         ;; Prompt for name
         "* %^{name}
 :PROPERTIES:
 :username: %^{username}
 :password: %(generate-password-non-interactive)
 :url: %^{url}

 :END:")
        ("u" "URL" entry
         (file+datetree media-file)
         "* %?\nURL: \nEntered on %U\n")))

(defun add-newline-at-end-if-none ()
  "Add a newline at the end of the buffer if there isn't any."
  (save-excursion
    (save-restriction
      (goto-char (1- (point-max)))
      (if (not (looking-at "\n\n"))
          (progn
            (goto-char (point-max))
            (insert "\n"))))))

(add-hook 'org-capture-before-finalize-hook 'add-newline-at-end-if-none)

(if (version<= "27.1" emacs-version)
    (require 'org-tempo))

;; Configure primary org pomodoro buffer to which the timers will get
;; attached to.
(setq ok-pomodoro-buffer "things.org")
(load "~/.emacs.d/org-pomodoro")

(setq org-todo-keywords
          '((sequence "TODO" "|" "DONE")
            (sequence "PROJECT" "AGENDA" "|" "MINUTES")
            (sequence "WAITING" "|" "PROGRESS")))

(setq org-duration-format '(("h" . t) (special . 2)))

(defun set-org-agenda-files ()
  "Set different org-files to be used in `org-agenda`."
  (setq org-agenda-files (list (concat org-directory "things.org")
                               (concat org-directory "reference.org")
                               (concat org-directory "media.org")
                               (concat org-directory "shared_with_monika/shared_alain_and_monika.org")
                               "~/src/200ok/admin/THINGS.org"
                               "~/src/200ok/admin/pm/bluewin/bluewin.org"
                               "~/src/200ok/admin/pm/fp/fp.org"
                               "~/src/200ok/admin/pm/accounting/accounting.org"
                               )))

(set-org-agenda-files)

(global-set-key "\C-cl" 'org-store-link)

(defun things ()
  "Open main 'org-mode' file and start 'org-agenda' for today."
  (interactive)
  (find-file (concat org-directory "things.org"))
  (set-org-agenda-files)
  (org-agenda-list)
  (org-agenda-day-view)
  (shrink-window-if-larger-than-buffer)
  (other-window 1))

(setq org-refile-targets (quote ((nil :maxlevel . 9) ;; local buffer
                                 (org-agenda-files :maxlevel . 4))))

(setq calendar-week-start-day 1)

(setq calendar-intermonth-text
      '(propertize
        (format "%2d"
                (car
                 (calendar-iso-from-absolute
                  (calendar-absolute-from-gregorian (list month day year)))))
        'font-lock-face 'font-lock-warning-face))

(setq calendar-intermonth-header
      (propertize "CW"
                  'font-lock-face 'font-lock-keyword-face))

(setq org-cycle-separator-lines 0)

(org-babel-do-load-languages
 'org-babel-load-languages
 '((restclient . t)))

(require 'org-download)

(add-hook 'dired-mode-hook 'org-download-enable)
(setq org-download-heading-lvl nil)

(setq-default org-download-heading-lvl nil)

(setq-default org-download-image-dir (concat org-directory "images"))

(setq org-habit-show-habits-only-for-today nil)

(require 'org-ai)
(add-hook 'org-mode-hook #'org-ai-mode)

(org-ai-install-yasnippets)
(setq org-ai-default-chat-model "gpt-3.5-turbo")
;; (setq org-ai-default-chat-model "gpt-4")
(add-hook 'org-mode-hook #'yas-minor-mode)

(define-key org-mode-map (kbd "C-c SPC") #'org-table-blank-field)

;; Show first notification 2h before event
(setq appt-message-warning-time (* 60 2))
;; Then, have a reminder every 30min
(setq appt-display-interval 30)
;; Don't display the 'time to appointment in minutes' in the modeline
(setq appt-display-mode-line nil)

;; ; Use appointment data from org-mode
;; (defun my-org-agenda-to-appt ()
;;   (interactive)
;;   (setq appt-time-msg-list nil)
;;   (org-agenda-to-appt))


;; ; Update alarms when...
;; ; (1) ... Starting Emacs
;; (my-org-agenda-to-appt)

;; ; (2) ... Everyday at 12:05am (useful in case you keep Emacs always on)
;; (run-at-time "12:05am" (* 24 3600) 'my-org-agenda-to-appt)

;; ; (3) ... When TODO.txt is saved
;; (add-hook 'after-save-hook
;;           '(lambda ()
;;              (if (string= (buffer-file-name) (concat (getenv "HOME") "/Dropbox/org/things.org"))
;;                  (my-org-agenda-to-appt))))

;; ; Display appointments as a window manager notification
;; (setq appt-disp-window-function 'my-appt-display)
;; (setq appt-delete-window-function (lambda () t))

;; (setq my-appt-notification-app (concat (getenv "HOME") "/bin/appt-notification"))

;; (defun my-appt-display (min-to-app new-time msg)
;;   (if (atom min-to-app)
;;     (start-process "my-appt-notification-app" nil my-appt-notification-app min-to-app msg)
;;   (dolist (i (number-sequence 0 (1- (length min-to-app))))
;;     (start-process "my-appt-notification-app" nil my-appt-notification-app (nth i min-to-app) (nth i msg)))))

(defadvice  org-agenda-redo (after org-agenda-redo-add-appts)
  "Pressing `r' on the agenda will also add appointments."
  (progn
    (defvar appt-time-msg-list nil)
    (org-agenda-to-appt)))

(ad-activate 'org-agenda-redo)

(progn
  (appt-activate 1)
  (setq appt-display-format 'window)
  (setq appt-disp-window-function (function my-appt-disp-window))
  (defun my-appt-disp-window (min-to-app new-time msg)
    (call-process (concat (getenv "HOME") "/bin/appt-notification") nil 0 nil min-to-app msg new-time)))

(add-hook 'after-save-hook
          '(lambda ()
             (when (seq-contains org-agenda-files (s-replace "/home/munen" "~" (buffer-file-name)))
                 (org-agenda-to-appt))))

(evil-set-initial-state 'pdf-view-mode 'emacs)
(add-hook 'pdf-view-mode-hook
  (lambda ()
    (set (make-local-variable 'evil-emacs-state-cursor) (list nil))))

(require 'elfeed)
(require 'elfeed-goodies)

(elfeed-goodies/setup)

(add-hook 'elfeed-show-mode-hook 'visual-line-mode)

(define-key elfeed-show-mode-map (kbd "C-e") 'evil-scroll-line-down)
(define-key elfeed-show-mode-map (kbd "C-y") 'evil-scroll-line-up)

(load "~/.emacs.d/elfeed-feeds.el")

(require 'atomic-chrome)
;; Handle if there is an Emacs instance running which has the server already
;; started
(ignore-errors
    ;; Start the server
    (atomic-chrome-start-server))

(setq atomic-chrome-default-major-mode 'markdown-mode)

(advice-add 'atomic-chrome-close-current-buffer
            :before
            '(lambda()
               (clipboard-kill-ring-save (point-min) (point-max))))

(require 'mu4e)

;; Not required from 1.8.7-2, it's already included
;; (require 'org-mu4e)

(setq send-mail-function 'smtpmail-send-it)

;; Default account on startup
(setq user-full-name  "Alain M. Lafon"
      mu4e-sent-folder "/200ok/INBOX.Sent"
      mu4e-drafts-folder "/200ok/INBOX.Drafts"
      mu4e-trash-folder "/200ok/INBOX.Trash")

(setq smtpmail-debug-info t
      message-kill-buffer-on-exit t
      ;; Custom script to run offlineimap in parallel for multiple
      ;; accounts as discussed here:
      ;; http://www.offlineimap.org/configuration/2016/01/29/why-i-m-not-using-maxconnctions.html
      ;; This halves the time for checking mails for 4 accounts for me
      ;; (when nothing has to be synched anyway)
      mu4e-get-mail-command "offlineimap_parallel.sh"
      mu4e-attachment-dir "~/Dropbox/org/files/inbox")

;; show full addresses in view message (instead of just names)
;; toggle per name with M-RET
(setq mu4e-view-show-addresses t)

;; Do not show related messages by default (toggle with =W= works
;; anyway)
(setq mu4e-headers-include-related nil)

;; Alternatives are the following, however in first tests they
;; show inferior results
;; (setq mu4e-html2text-command "textutil -stdin -format html -convert txt -stdout")
;; (setq mu4e-html2text-command "html2text -utf8 -width 72")
;; (setq mu4e-html2text-command "w3m -dump -T text/html")

(defvar my-mu4e-account-alist
  '(("200ok"
     (user-full-name  "Alain M. Lafon")
     (mu4e-compose-signature "200ok GmbH\nCEO\n\n[email protected]\n+41 76 405 05 67\nhttps://200ok.ch/\n\norganice is the best way to get stuff done: https://organice.200ok.ch")
     (mu4e-compose-signature-auto-include t)
     (mu4e-sent-folder "/200ok/INBOX.Sent")
     (mu4e-drafts-folder "/200ok/INBOX.Drafts")
     (mu4e-trash-folder "/200ok/INBOX.Trash")
     (user-mail-address "[email protected]")
     (smtpmail-default-smtp-server "mail.your-server.de")
     (smtpmail-local-domain "200ok.ch")
     (smtpmail-smtp-user "[email protected]")
     (smtpmail-smtp-server "mail.your-server.de")
     (smtpmail-stream-type starttls)
     (smtpmail-smtp-service 25))
    ("zen-tempel"
     (user-full-name  "Munen Alain M. Lafon")
     (mu4e-compose-signature "Lambda Zen Tempel\n\n[email protected]\n+41 76 405 05 67\n\nhttps://zen-temple.net/")
     (mu4e-compose-signature-auto-include t)
     (mu4e-sent-folder "/zen-tempel/INBOX.Sent")
     (mu4e-drafts-folder "/zen-tempel/INBOX.Drafts")
     (mu4e-trash-folder "/zen-tempel/INBOX.Trash")
     (user-mail-address "[email protected]")
     (smtpmail-default-smtp-server "mail.your-server.de")
     (smtpmail-local-domain "zen-tempel.ch")
     (smtpmail-smtp-user "[email protected]")
     (smtpmail-smtp-server "mail.your-server.de")
     (smtpmail-stream-type starttls)
     (smtpmail-smtp-service 25))
    ("dispatched"
     (user-full-name  "Alain M. Lafon")
     (mu4e-compose-signature-auto-include nil)
     (mu4e-sent-folder "/dispatched/INBOX.Sent")
     (mu4e-drafts-folder "/dispatched/INBOX.Drafts")
     (mu4e-trash-folder "/dispatched/INBOX.Trash")
     (user-mail-address "[email protected]")
     (smtpmail-default-smtp-server "mail.your-server.de")
     (smtpmail-local-domain "dispatched.ch")
     (smtpmail-smtp-user "[email protected]")
     (smtpmail-smtp-server "mail.your-server.de")
     (smtpmail-stream-type starttls)
     (smtpmail-smtp-service 25))))

;; Whenever a new mail is to be composed, change all relevant
;; configuration variables to the respective account. This method is
;; taken from the MU4E documentation:
;; http://www.djcbsoftware.nl/code/mu/mu4e/Multiple-accounts.html#Multiple-accounts
(defun my-mu4e-set-account ()
  "Set the account for composing a message."
  (let* ((account
          (if mu4e-compose-parent-message
              (let ((maildir (mu4e-message-field mu4e-compose-parent-message :maildir)))
                (string-match "/\\(.*?\\)/" maildir)
                (match-string 1 maildir))
            (completing-read (format "Compose with account: (%s) "
                                     (mapconcat #'(lambda (var) (car var))
                                                my-mu4e-account-alist "/"))
                             (mapcar #'(lambda (var) (car var)) my-mu4e-account-alist)
                             nil t nil nil (caar my-mu4e-account-alist))))
         (account-vars (cdr (assoc account my-mu4e-account-alist))))
    (if account-vars
        (mapc #'(lambda (var)
                  (set (car var) (cadr var)))
              account-vars)
      (error "No email account found"))))

(add-hook 'mu4e-compose-pre-hook 'my-mu4e-set-account)

(add-hook 'mu4e-compose-mode-hook 'visual-line-mode)

(setq mu4e-refile-folder
      (lambda (msg)
        (cond
         ((string-match "^/dispatched.*"
                        (mu4e-message-field msg :maildir))
          "/dispatched/INBOX.Archive")
         ((string-match "^/zen-tempel.*"
                        (mu4e-message-field msg :maildir))
          "/zen-tempel/INBOX.Archive")
         ((string-match "^/200ok.*"
                        (mu4e-message-field msg :maildir))
          "/200ok/INBOX.Archive")
         ((string-match "^/zhaw.*"
                        (mu4e-message-field msg :maildir))
          "/zhaw/Archive")
         ;; everything else goes to /archive
         (t  "/archive"))))


;; Empty the initial bookmark list
(setq mu4e-bookmarks '())


;; All archived folders
(defvar d-archive "NOT (maildir:/dispatched/INBOX.Archive OR maildir:/zen-tempel/INBOX.Archive OR maildir:/200ok/INBOX.Archive OR maildir:/zhaw/Archive)")

(defvar inbox-folders (string-join '("maildir:/dispatched/INBOX"
                                     "maildir:/zen-tempel/INBOX"
                                     "maildir:/200ok/INBOX")
                                   " OR "))

(defvar draft-folders (string-join '("maildir:/dispatched/INBOX.Drafts"
                                     "maildir:/zen-tempel/INBOX.Drafts"
                                     "maildir:/200ok/INBOX.Drafts")
                                   " OR "))

(defvar spam-folders (string-join '("maildir:/dispatched/INBOX.spambucket"
                                     "maildir:/zen-tempel/INBOX.spambucket"
                                     "maildir:/200ok/INBOX.spambucket")
                                  " OR "))

(defvar blacklist-folders (string-join
'("maildir:/dispatched/INBOX.blacklist"
"maildir:/zen-tempel/INBOX.blacklist"
"maildir:/200ok/INBOX.blacklist") " OR "))

;; Re-define all standard bookmarks to not include the spam and
;; blacklist folders for searches
(defvar d-spam (format "NOT (%s OR %s)" spam-folders blacklist-folders))

(add-to-list 'mu4e-bookmarks
             '((concat d-spam " AND date:today..now")                  "Today's messages"     ?t))
(add-to-list 'mu4e-bookmarks
             '((concat d-spam " AND date:7d..now")                     "Last 7 days"          ?w))
(add-to-list 'mu4e-bookmarks
             '((concat d-spam " AND flag:flagged")                     "Flagged"              ?f))
(add-to-list 'mu4e-bookmarks
             '((concat d-spam " AND mime:image/*")                     "Messages with images" ?p))
(add-to-list 'mu4e-bookmarks
             '(spam-folders "Spam"     ?S))
(add-to-list 'mu4e-bookmarks
             '(blacklist-folders "Blacklisted"     ?B))
(add-to-list 'mu4e-bookmarks
             '(draft-folders "Drafts"     ?d))
(add-to-list 'mu4e-bookmarks
             '(inbox-folders "Inbox"     ?i))
(add-to-list 'mu4e-bookmarks
             '((concat d-spam d-archive " AND (flag:unread OR flag:flagged) AND NOT flag:trashed")
               "Unread messages"      ?u))
;; Hack to get to a temporary inbox zero state when starting a new year
(add-to-list 'mu4e-bookmarks
             '((concat d-spam d-archive (concat " (flag:unread OR flag:flagged) AND NOT flag:trashed AND date:" (format-time-string "%Y")))
               "Unread messages, current year"      ?U))

(defun ok/message-attachment-present-p ()
  "Return t if a non-gpg attachment is found in the current message."
  (save-excursion
    (save-restriction
      (widen)
      (goto-char (point-min))
      (when (search-forward "<#part type" nil t) t))))

(setq ok/message-attachment-regexp
  (regexp-opt '("[Ww]e send"
                "[Ii] send"
                "attach"
                "[aA]ngehängt"
                "[aA]nhang"
                "[sS]chicke"
                "angehaengt"
                "haenge"
                "hänge")))

(defun ok/message-warn-if-no-attachments ()
  "Check if there is an attachment in the message if I claim it."
  (when (and (save-excursion
         (save-restriction
     (widen)
     (goto-char (point-min))
     (re-search-forward ok/message-attachment-regexp nil t)))
       (not (ok/message-attachment-present-p)))
    (unless (y-or-n-p "No attachment. Send the message?")
      (keyboard-quit))))

(add-hook 'message-send-hook #'ok/message-warn-if-no-attachments)

(setq mu4e-compose-complete-only-after (format-time-string
                                        "%Y-%m-%d"
                                        (time-subtract (current-time) (days-to-time 150))))

(require 'mu4e-contrib)
(setq mu4e-html2text-command 'mu4e-shr2text)
;;(setq mu4e-html2text-command "iconv -c -t utf-8 | pandoc -f html -t plain")
(add-to-list 'mu4e-view-actions '("ViewInBrowser" . mu4e-action-view-in-browser) t)

(setq shr-use-colors t)

(setq mu4e-view-html-plaintext-ratio-heuristic  most-positive-fixnum)

(add-hook 'mu4e-compose-mode-hook 'flyspell-mode)

(setq mu4e-update-interval (* 15 60))
(setq mu4e-index-update-in-background t)

(setq mu4e-compose-crypto-reply-plain-policy 'sign)

(setq mml-secure-openpgp-encrypt-to-self t)
(setq mml-secure-openpgp-sign-with-sender  t)

;; (add-hook 'mu4e-compose-mode-hook 'epa-mail-mode)
;; (add-hook 'mu4e-view-mode-hook 'epa-mail-mode)

;; (add-hook 'mu4e-view-mode-hook 'visual-line-mode)

(setq mu4e-compose-dont-reply-to-self t)

(setq org-mu4e-link-query-in-headers-mode nil)

(setq mu4e-view-fields '(:from :to :cc :bcc :subject :flags :date :maildir :mailing-list :tags :attachments :signature :decryption))

(setq mu4e-confirm-quit nil)

(add-hook 'mu4e-compose-mode-hook
  (defun ok-mu4e-keep-to-three-sentences ()
    (shell-command "notify-send -u critical 'Keep to three sentences.'")
    (message "Keep to three sentences.")))

(setq mu4e-headers-date-format "%+4Y-%m-%d")

(setq mu4e-compose-format-flowed t)

(setq fill-flowed-encode-column 998)

(setq mu4e-msg2pdf "/usr/local/bin/msg2pdf")

(setq mu4e-headers-skip-duplicates nil)

(require 'mu4e-icalendar)
(mu4e-icalendar-setup)
(setq gnus-icalendar-org-capture-file "~/Dropbox/org/things.org")
(setq gnus-icalendar-org-capture-headline '("Calendar"))
(gnus-icalendar-org-setup)

(defun append-line-to-file (line path)
  "Append a `line` to a file behind `path`"
  (write-region (concat line "\n") nil path 'append))

(defun mu4e-strategy-from (strategy msg)
  "If STRATEGY is 'blacklist', then add the `from` of a message to the
procmail. If it is 'whitelist', then whitelist'."
  (let* ((from (mu4e-message-field msg :from))
         (from_name (car (cdr (car from))))
         (from_address (car (cdr (cdr (cdr (car from))))))
         (path (format "~/.procmail/%s_from.txt" strategy)))
    ;; Whitelist/Blacklist the senders Name
    (if from_name
        (append-line-to-file from_name path))
    ;; Whitelist/Blacklist the Email-Address
    (append-line-to-file from_address path)
    (shell-command (format "sort -u -o %s %s" path path))
    (message "%s: %s" strategy from)))


(defun mu4e-blacklist-subject (msg)
  "Add the `subject` of a message to the procmail blacklist"
  (let* ((subject (mu4e-message-field msg :subject))
         (path "~/.procmail/blacklist_subject.txt"))
    (if subject
        (append-line-to-file subject path))
    (shell-command (format "sort -u -o %s %s" path path))

    (message "Blacklist: %s" subject)))

(add-to-list 'mu4e-headers-actions
  '("f White 'From:'" . (lambda (msg) (mu4e-strategy-from "whitelist" msg))) t)

(add-to-list 'mu4e-headers-actions
  '("F Block 'From:'" . (lambda (msg) (mu4e-strategy-from "blacklist" msg))) t)

(add-to-list 'mu4e-headers-actions
             '("S Block 'Subject:'" . mu4e-blacklist-subject) t)

(defun munen-contact-processor (contact)
  (cond
   ((string-match "[email protected]" contact) ; Phil sometimes dosn't add his name to the reply-to.
    "Phil Hofmann <[email protected]>")
   ((string-match "[email protected]" contact) ; Monika writes her name in all caps and I don't want to forward it like that.
   "Monika Bieri <[email protected]>"
    )
   (t contact)))

(setq mu4e-contact-process-function 'munen-contact-processor)

(ido-mode t)
(ido-everywhere t)
(setq ido-enable-flex-matching t)

(setq enable-recursive-minibuffers t)
(global-set-key (kbd "<f6>") 'ivy-resume)

(setq ivy-count-format "(%d/%d) ")

(setq ivy-wrap t)

(global-set-key "\C-s" 'swiper)

(global-set-key (kbd "C-x b") 'counsel-ibuffer)
(global-set-key (kbd "C-h d") 'counsel-describe-function)
(global-set-key (kbd "C-h v") 'counsel-describe-variable)
;; Run `counsel-ag` against the current directory and not against the
;; whole project
(global-set-key (kbd "C-c k") '(lambda()
                                 (interactive)
                                 (counsel-ag "" default-directory nil nil)))
(global-set-key (kbd "C-x l") 'counsel-locate)
(define-key minibuffer-local-map (kbd "C-r") 'counsel-minibuffer-history)

(define-key org-mode-map (kbd "C-c C-j") 'counsel-org-goto)

(global-set-key (kbd "C-x i") 'counsel-imenu)

(global-set-key (kbd "C-x C-f") 'counsel-find-file)
(global-set-key (kbd "C-x d") 'counsel-dired)

(global-set-key (kbd "M-x") (lambda ()
                              (interactive)
                              (counsel-M-x "")))

(global-set-key (kbd "C-x 8 RET") 'counsel-unicode-char)

(setq ivy-use-selectable-prompt t)

(add-hook 'pdf-view-mode-hook '(lambda()
                                 (define-key pdf-view-mode-map "\C-s" 'isearch-forward)))

(setq projectile-completion-system 'ivy)

(setq mu4e-completing-read-function 'ivy-completing-read)

(setq synosaurus-choose-method 'ivy-read)

;;(global-set-key (kbd "C-s") 'isearch-forward-regexp)
;;(global-set-key (kbd "C-r") 'isearch-backward-regexp)

(setq erc-autojoin-channels-alist '(("libera.chat" "#organice" "#200ok" "#emacsconf" "#emacsconf-org" "#lobsters")
                                      ;; Deprecate Freenode (rationale https://github.com/200ok-ch/org-parser/pull/48)
                                      ;; ("freenode.net" "#200ok" "#emacsconf" "#emacsconf-org" "#lobsters")
                                      ;; This does not work, yet. The
                                      ;; channels cannot be joined on
                                      ;; connecting to bitlbee. bitlbee
                                      ;; needs to first connect to the
                                      ;; configured accounts (i.e.
                                      ;; slack). This could happen in a
                                      ;; timeout, or better event
                                      ;; oriented on a message that
                                      ;; bitlbee sends when connected to
                                      ;; the account.
                                      ;; '(("localhost" "#internal" "#general"))
                                      ))

(defconst erc-default-server "irc.libera.chat")

(setq erc-lurker-hide-list '("JOIN" "PART" "QUIT"))

(require 'erc-image)
(add-to-list 'erc-modules 'image)
(erc-update-modules)

(setq erc-log-channels-directory "~/.erc/logs/")
(add-hook 'erc-insert-post-hook 'erc-save-buffer-in-logs)

(setq erc-pals '("phi|" "branch14"))
;; The quotes around %s are super important to prevent shell injection
(add-hook 'erc-text-matched-hook '(lambda(match-type nickuserhost msg)
                                    (shell-command-to-string (format "notify-send erc '%s'" msg))))

(require 'spaceline)

;; This is throwing errors when debugging elisp since [2022-12-06 Tue].

; (spaceline-define-segment ph/flycheck-warning-segment
;   (if (flycheck-has-current-errors-p)
;       (let ((c (cdr (assq 'warning (flycheck-count-errors
;                                     flycheck-current-errors)))))
;         (powerline-raw
;          (if c (format "%s" c))))))

(spaceline-define-segment ph/flycheck-error-segment
  (if (flycheck-has-current-errors-p)
      (let ((c (cdr (assq 'error (flycheck-count-errors
                                    flycheck-current-errors)))))
        (powerline-raw
         (if c (format "%s" c))))))

(spaceline-define-segment ph/flycheck-info-segment
  (if (flycheck-has-current-errors-p)
      (let ((c (cdr (assq 'info (flycheck-count-errors
                                    flycheck-current-errors)))))
        (powerline-raw
         (if c (format "%s" c))))))

(defface ph/spaceline-flycheck-error-face
  '((t :inherit 'mode-line
       :weight bold
       :foreground "white"
       :background "dark red"))
  "Flycheck Error Face"
  :group 'spaceline)

(defface ph/spaceline-flycheck-warning-face
  '((t :inherit 'mode-line
       :weight bold
       :foreground "white"
       :background "DarkOrange3"))
  "Flycheck Warning Face"
  :group 'spaceline)

(defface ph/spaceline-flycheck-info-face
  '((t :inherit 'mode-line
       :weight bold
       :foreground "white"
       :background "dark green"))
  "Flycheck Info Face"
  :group 'spaceline)

(defun ph/spaceline-highlight-face-evil-state ()
  "Set the highlight face depending on the evil state."
  (if (bound-and-true-p evil-local-mode)
      (let* ((face (assq evil-state spaceline-evil-state-faces)))
        (if face (cdr face) (spaceline-highlight-face-default)))
    (spaceline-highlight-face-default)))

(setq-default spaceline-highlight-face-func
              'ph/spaceline-highlight-face-evil-state)

(defface ph/spaceline-evil-operator-face
  '((t (:background "cornflower blue"
        :inherit 'spaceline-evil-normal)))
  "Spaceline Evil Operator State"
  :group 'spaceline)

(add-to-list 'spaceline-evil-state-faces
             '(operator . ph/spaceline-evil-operator-face))

(defun ph/git-branch-name ()
  (replace-regexp-in-string "^ Git[:-]" "" vc-mode))

(spaceline-define-segment ph/version-control
  "Version control information."
  (when vc-mode
    (s-trim (concat (ph/git-branch-name)))))

(spaceline-define-segment ph/remote-method
  (when (and default-directory
             (file-remote-p default-directory 'method))
    (file-remote-p default-directory 'method)))

(spaceline-define-segment ph/remote-user-and-host
  (when (and default-directory
             (or
              (file-remote-p default-directory 'user)
              (file-remote-p default-directory 'host)))
    (concat
     (file-remote-p default-directory 'user) "@"
     (file-remote-p default-directory 'host))))

(defface ph/spaceline-tramp-user-host-face
  '((t :inherit 'mode-line
       :foreground "black"
       :background "#fce94f"))
  "Tramp User@Host Face"
  :group 'spaceline)

(defface ph/spaceline-tramp-method-face
  '((t :inherit 'mode-line
       :foreground "black"
       :background "#ff5d17"))
  "Tramp Method Face"
  :group 'spaceline)

;; (spaceline-define-segment ph/mu4e-context-segment
;;   (let ((context (mu4e-context-current)))
;;     (when (and context
;;                (string-prefix-p "mu4e" (symbol-name major-mode)))
;;       (mu4e-context-name context))))

;; (defface ph/spaceline-mu4e-context-face
;;   '((t :inherit 'mode-line
;;        :weight bold))
;;   "mu4e face"
;;   :group 'spaceline)

(spaceline-define-segment org-timer-left-time
  "Show the time left in the current org-timer (i.e. a pomodoro)."
  (when (boundp 'org-timer-countdown-timer)
    (if org-timer-countdown-timer
      (let* ((rtime (decode-time
                     (time-subtract (timer--time org-timer-countdown-timer)
                                    (current-time))))
             (rsecs (nth 0 rtime))
             (rmins (nth 1 rtime))
             ;; Show time only in 15s increments (so it's not too
             ;; distracting). This could probably done in math instead
             ;; of a cond statement.
             (dsecs (cond
                     ((>= rsecs 45) 45)
                     ((>= rsecs 30) 30)
                     ((>= rsecs 15) 15)
                     ;; Usually round seconds down to 0.
                     ((and
                       (< rsecs 15)
                       (> rmins 0)) 0)
                     ;; Unless it's less than 15 secs left, then
                     ;; actually count down.
                     ((and
                       (< rsecs 15)
                       (= rmins 0)) rsecs))))
        (format "%02d:%02d" rmins dsecs)))))

(require 'spaceline-config)
(spaceline-spacemacs-theme)

;; Otherwise spaceline will be huge in Emacs >= 27.1
;; (setq powerline-height 1)
;; Since Emacs >= 28.2, it needs to be bigger to stay the same size.
(setq powerline-height 22)
;; Since Emacs >= 27.1, there's no need for font trickery. Just use
;; UTF-8.
;; (setq powerline-default-separator 'utf-8)

(spaceline-install
  'main
  '((evil-state :face highlight-face)
    (buffer-id)
    (org-timer-left-time)
    ;; (ph/mu4e-context-segment :face 'ph/spaceline-mu4e-context-face)
    (ph/remote-method :face 'ph/spaceline-tramp-method-face)
    (ph/remote-user-and-host :face 'ph/spaceline-tramp-user-host-face)
    (buffer-modified))
  '(;;(minor-modes :when active)
    (projectile-root)
    (ph/version-control)
    ;(line-column :when active)
    ;(buffer-position :when active)
    (ph/flycheck-info-segment :face 'ph/spaceline-flycheck-info-face :when active)
    (ph/flycheck-warning-segment :face 'ph/spaceline-flycheck-warning-face :when active)
    (ph/flycheck-error-segment :face 'ph/spaceline-flycheck-error-face :when active)
    (line-column)
    (major-mode)))

(defun powerline-selected-window-active () t)

(eval-after-load "auto-revert"
  '(diminish 'auto-revert-mode))
(eval-after-load "beacon"
  '(diminish 'beacon-mode))
(eval-after-load "ivy"
  '(diminish 'ivy-mode))
(eval-after-load "projectile"
  '(diminish 'projectile-mode))
(eval-after-load "projectile-rails"
  '(diminish 'projectile-rails-mode))
(eval-after-load "rainbow-mode"
  '(diminish 'rainbow-mode))
(eval-after-load "undo-tree"
  '(diminish 'undo-tree-mode))
(eval-after-load "which-key"
  '(diminish 'which-key-mode))

(require 'hide-mode-line)

(add-hook 'pdf-view-mode-hook #'hide-mode-line-mode)

(setq synosaurus-backend 'synosaurus-backend-openthesaurus)

(defalias 'thesaurus-openthesaurus-de 'synosaurus-lookup)

(setq flyspell-sort-corrections nil)

(setq flyspell-issue-message-flag nil)

(with-eval-after-load "ispell"
  ;; Configure `LANG`, otherwise ispell.el cannot find a 'default
  ;; dictionary' even though multiple dictionaries will be configured
  ;; in next line.
  (setenv "LANG" "en_US.UTF-8")
  (setq ispell-program-name "hunspell")
  ;; Configure German, Swiss German, and two variants of English.
  (setq ispell-dictionary "de_DE,de_CH,en_GB,en_US")
  ;; ispell-set-spellchecker-params has to be called
  ;; before ispell-hunspell-add-multi-dic will work
  (ispell-set-spellchecker-params)
  (ispell-hunspell-add-multi-dic "de_DE,de_CH,en_GB,en_US")
  ;; For saving words to the personal dictionary, don't infer it from
  ;; the locale, otherwise it would save to ~/.hunspell_de_DE.
  (setq ispell-personal-dictionary "~/.hunspell_personal"))

;; The personal dictionary file has to exist, otherwise hunspell will
;; silently not use it.
(unless (file-exists-p ispell-personal-dictionary)
        (write-region "" nil ispell-personal-dictionary nil 0))

;; (defun flyspell-buffer-after-pdict-save (&rest _)
;;   (flyspell-buffer))

;; (advice-add 'ispell-pdict-save :after #'flyspell-buffer-after-pdict-save)

;; (defun flyspell-switch-dictionary()
;;   "Switch between German and English dictionaries"
;;   (interactive)
;;   (let* ((dic ispell-current-dictionary)
;;          (change (if (string= dic "deutsch") "english" "deutsch")))
;;     (ispell-change-dictionary change)
;;     (message "Dictionary switched from %s to %s" dic change)))

(when (eq system-type 'gnu/linux)

      (add-to-list 'default-frame-alist
                   '(font . "Fira Code Retina 9"))

      ;; In the past, this was the name for the same font:

      ;; (add-to-list 'default-frame-alist
      ;;              '(font . "Fira CodeSource Code Pro Retina 9"))
      ;; (set-face-attribute 'default t :font "Fira Code Retina 9")


      ;; This is a great fallback font. It looks very similar and
      ;; comes preinstalled on many systems.

      ;; (add-to-list 'default-frame-alist
      ;;              '(font . "DejaVu Sans Mono 9"))

      ;; Manually setting the font
      ;; (set-frame-font "Fira Code Retina 9")

  ;; Default Browser
  (setq browse-url-browser-function 'browse-url-generic
        browse-url-generic-program "firefox"
        browse-url-new-window-flag t)
  (menu-bar-mode -1)
  ;; enable pdf-tools
  (pdf-tools-install))

;; (set-fontset-font t nil "Symbola" nil 'prepend)

(set-fontset-font t nil "Noto Color Emoji" nil 'prepend)
;; (set-fontset-font t '(#x1f000 . #x1faff)
;;               (font-spec :family "Noto Color Emoji"))

(when (eq system-type 'darwin)
  (set-frame-font "Menlo 14")
  ; Use Spotlight to search with M-x locate
  (setq locate-command "mdfind"))

(setq custom-safe-themes
   (quote
    ("df3e05e16180d77732ceab47a43f2fcdb099714c1c47e91e8089d2fcf5882ea3"
     "d09467d742f713443c7699a546c0300db1a75fed347e09e3f178ab2f3aa2c617"
     "8db4b03b9ae654d4a57804286eb3e332725c84d7cdab38463cb6b97d5762ad26"
     "85c59044bd46f4a0deedc8315ffe23aa46d2a967a81750360fb8600b53519b8a"
     default)))

(defun dark-mode ()
  "Default theme and font size.  Pendant: (presentation-mode)."
  (interactive)

  (mapcar 'disable-theme custom-enabled-themes)
  (set-face-attribute 'default nil :height 150)
  ;; Themes
  ;; (set-frame-parameter nil 'background-mode 'dark)

  ;; Dark, High Contrast <- favorite
  (load-theme 'wombat)
  (setq frame-background-mode (quote dark))

  ;; Dark, Low contrast
  ;; (load-theme 'darktooth)
  ;; Dark, Lowest contrast
  ;; (load-theme 'zenburn)
   )

(defun light-mode ()
  "Enables a light theme."
  (interactive)
  ;; (set-face-attribute 'default nil :height 100)
  (mapcar 'disable-theme custom-enabled-themes)
  (load-theme 'spacemacs-light t))

(defun presentation-mode ()
  "Presentation friendly theme and font size."
  (interactive)
  (load-theme 'leuven t)
  (mapcar 'disable-theme custom-enabled-themes)
  (set-face-attribute 'default nil :height 150))

(add-hook 'server-after-make-frame-hook 'light-mode)
(light-mode)

(require 'seq)

(defun ok-filter-table-by-date (tbl from-date table-row)
  "Filter a TBL by FROM-DATE which is found in TABLE-ROW."
  ;; Sort by date
  (seq-sort '(lambda (e1 e2)
               (string-lessp (nth table-row e1)
                             (nth table-row e2)))
            ;; Filter to start with FROM-DATE
            (seq-filter (lambda (elem)
                          (let ((date-elem (nth table-row elem)))
                            ;; >=
                            (when (or (string-greaterp date-elem from-date)
                                      (string-equal date-elem from-date))
                              elem)))
                        tbl)))

(defun ok-hm-to-hours (worktime)
  "Casts HH:MM WORKTIME into a floating point number."
  (condition-case worktime
      (let* ((time (split-string worktime ":"))
             (minutes (/ (string-to-number (second time))
                         60.0))
             (hours (string-to-number (first time))))
        (format "%.3f" (+ hours minutes)))
    (error 0)))

(defun ok-split-hash-and-description (text)
  "Given a TEXT like '#tag1 #tag2 some description' and return tags and description as a list."
  ;; The concat is a little hack, so that there's always a minimum
  ;; description to be found
  (let ((text (concat text " ")))
    ;; A hashtag can have numbers, dashes and a-z
    (if (string-match "\\(#[a-z-0-9]+ \\)+" text)
        (let* ((hashtags (match-string 0 text))
               ;; Couldn't figure out how to get the description
               ;; through an elisp regexp, so I'm just reading the
               ;; remainder of the text after all hashtags here
               (description (substring text (length hashtags) (length text))))
          (list
           (string-trim hashtags)
           (string-trim description))))))

(defun ok-find-parent-of-type (elem-type elem)
  "For a child ELEM, find the closes parent element of type ELEM-TYPE."
  (let ((parent-elem (org-element-property :parent elem)))
    (if (eq elem-type (car parent-elem))
        parent-elem
      (ok-find-parent-of-type elem-type parent-elem))))

(defun ok-generate-clock-table ()
  "Generate a list of org elements of type 'clock."
  (let* ((ast (org-element-parse-buffer 'element)))
    ;; Map a function to all elements of TYPE 'clock which extracts
    ;; the TITLE, DURATION and DATE of a TODO.
    (org-element-map ast 'clock
      (lambda (clock-elem)
        (let* ((val (org-element-property :value clock-elem))
               (task (ok-find-parent-of-type 'headline clock-elem))
               (hash-and-description (ok-split-hash-and-description
                                      (org-element-property :title task))))
          `(,(let ((year (org-element-property :year-start val))
                   (month (org-element-property :month-start val))
                   (day (org-element-property :day-start val)))
               (format "%4d-%02d-%02d" year month day ))
            ,(ok-hm-to-hours (org-element-property :duration clock-elem))
            ,(first hash-and-description)
            ,(second hash-and-description)))))))

(defun ok-export-org-timetable (from-date)
  "Generate a list from 'org-mode' clock elements starting from FROM-DATE."
  ;; Concatenate header, element data and footer into one list which
  ;; will automatically be rendered by org-mode as a table.
  (append
   '(("date" "duration" "hashtags" "description"))
   '(hline)
   ;; Generate tree of all visible elements within buffer (narrowing
   ;; works).
   (ok-filter-table-by-date (ok-generate-clock-table) from-date 0)))


(defun ok-export-table-to (table-name target-path)
  "Exports the contents of a table called TABLE-NAME to a CSV file at TARGET-PATH."
  (progn
    (save-excursion
      (goto-char (point-min))
      (search-forward (concat "RESULTS: " table-name))
      (org-cycle)
      (evil-next-line)
      (org-table-export target-path "orgtbl-to-csv")
      (evil-previous-line))
      (org-cycle))
    (message "Table export completed"))

(setq ok-export-org-estimations-file "~/src/200ok/admin/src/export-org-estimations/ok-export-org-estimations.el")
(unless (file-exists-p ok-export-org-estimations-file)
  (load-file ok-export-org-estimations-file))

(setq org-html-validation-link nil)

(setq org-export-with-planning t)

;; Setting dummy vars for private variables.
(setq org-agenda-private-local-path "/tmp/dummy.ics")
(setq org-agenda-private-remote-path "/sshx:user@host:path/dummy.ics")

;; Export the agenda for the next month (default is week)
(setq org-agenda-span (quote month))

;; Override the dummy values from above.
(if (file-exists-p "~/.emacs.d/private_config.el")
    (load-file "~/.emacs.d/private_config.el"))

(setq org-agenda-custom-commands
      `(;; Agenda to only show personal GTD files and filter work
        ;; related files which is easy to add with `#+FILETAGS: 200ok`.
        ("c" "Custom agenda, ignore 200ok tag"
         ((agenda ""))
         ((org-agenda-tag-filter-preset '("-200ok"))))
        ;; Define a custom command to save the org agenda to a file
        ("X" agenda "" nil ,(list org-agenda-private-local-path))))

(defun org-agenda-export-to-ics ()
  (set-org-agenda-files)
  ;; Run all custom agenda commands that have a file argument.
  (org-batch-store-agenda-views)

  ;; Org mode correctly exports TODO keywords as VTODO events in ICS.
  ;; However, some proprietary calendars do not really work with
  ;; standards (looking at you Google), so VTODO is ignored and only
  ;; VEVENT is read.
  (with-current-buffer (find-file-noselect org-agenda-private-local-path)
    (goto-char (point-min))
    (while (re-search-forward "VTODO" nil t)
      (replace-match "VEVENT"))
    (save-buffer))

  ;; Copy the ICS file to a remote server (Tramp paths work).
  (copy-file org-agenda-private-local-path org-agenda-private-remote-path t))

(require 'hl-todo)

 (setq hl-todo-keyword-faces
  '(("TODO"  . "#DF5427")  ; A concrete TODO with actionable steps
    ("FIXME" . "#DF5427")  ; A non-concrete TODO. We only know something is broken/amiss.
    ("HACK"  . "#DF5427")  ; Works, but is a code smell (quick fix). Might break down the line.
    ("CHECK" . "#CC6437")  ; Assumption that needs to be verified.
    ("NOTE"  . "#1FDA9A")  ; Use to highlight a regular, but especially important, comment.
    ("INFO"  . "#1FDA9A")  ; Use to highlight a regular, but especially important, comment.
    ))

(define-key hl-todo-mode-map (kbd "C-c t p") 'hl-todo-previous)
(define-key hl-todo-mode-map (kbd "C-c t n") 'hl-todo-next)
(define-key hl-todo-mode-map (kbd "C-c t o") 'hl-todo-occur)
(define-key hl-todo-mode-map (kbd "C-c t i") 'hl-todo-insert)

(add-hook 'prog-mode-hook 'hl-todo-mode)
(add-hook 'conf-mode-hook 'hl-todo-mode)

;; (add-to-list 'after-init-hook 'clipmon-mode-start)