;;; ellis.el --- Richard's custom Emacs config -*- lexical-binding: t; -*-

 ;; Copyright (C) 2024

 ;; Author: Richard Westhaver <ellis@rwest.io>

 ;; This program is free software; you can redistribute it and/or modify

 ;; it under the terms of the GNU General Public License as published by

 ;; the Free Software Foundation, either version 3 of the License, or

 ;; (at your option) any later version.

 ;; This program is distributed in the hope that it will be useful,

 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of

 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 ;; GNU General Public License for more details.

 ;; You should have received a copy of the GNU General Public License

 ;; along with this program.  If not, see <https://www.gnu.org/licenses/>.

 ;;; Commentary:

 ;; This is an example of what you may want to add to your custom

 ;; config file. Feel free to rip.

 ;;; Code:

 (require 'inbox)

 (require 'sk)

 (require 'sxp)

 (require 'ulang)

 (defalias 'make #'compile)

 (setopt default-theme 'modus-vivendi-tritanopia

         user-lab-directory (join-paths user-home-directory "lab")

         company-source-directory (join-paths user-home-directory "comp"))

 ;; (unless (display-graphic-p) (setq default-theme 'wheatgrass))

 (when (linux-p) (setq dired-listing-switches "-alsh"))

 (defvar emacs-config-source (join-paths company-source-directory "core/emacs"))

 ;;;###autoload

 (defun edit-emacs-config (&optional src)

   (interactive (list current-prefix-arg))

   (let ((file (if src 

                   (expand-file-name "default.el" emacs-config-source) 

                 user-custom-file)))

     (find-file file)))

 (keymap-set user-map "e c" #'edit-emacs-config)

 (keymap-set emacs-lisp-mode-map "C-c C-l" #'load-file)

 (keymap-set emacs-lisp-mode-map "C-c M-k" #'elisp-byte-compile-file)

 (keymap-set user-map "v t" #'org-tags-view)

 (require 'paredit)

 (repeat-mode)

 (defun remember-project ()

   (interactive)

   (project-remember-project (project-current))

   project--list)

 (defun remember-lab-projects ()

   (interactive)

   (project-remember-projects-under user-lab-directory t))

 (defun remember-comp-projects ()

   (interactive)

   (project-remember-projects-under company-source-directory t))

 (keymap-global-set "C-<tab>" #'hippie-expand)

 (keymap-set minibuffer-local-map "C-<tab>" #'hippie-expand)

 (keymap-set ctl-x-x-map "p p" #'remember-project)

 (keymap-set ctl-x-x-map "p l" #'remember-lab-projects)

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

 (add-hook 'org-mode-hook #'skel-minor-mode)

 ;; (add-hook 'prog-mode-hook #'company-mode)

 (add-hook 'notmuch-message-mode-hook #'turn-on-orgtbl)

 (use-package markdown-mode :ensure t)

 (use-package ol-notmuch :ensure t)

 (use-package notmuch 

   :ensure t

   :init

   (setopt

    mail-user-agent 'message-user-agent

    smtpmail-smtp-server "smtp.gmail.com"

    message-send-mail-function 'message-smtpmail-send-it

    smtpmail-debug-info t

    message-default-mail-headers "Cc: \nBcc: \n"

    message-kill-buffer-on-exit t

    user-mail-address "richard.westhaver@gmail.com"

    user-full-name "Richard Westhaver"

    notmuch-hello-sections '(notmuch-hello-insert-saved-searches 

                             notmuch-hello-insert-search 

                             notmuch-hello-insert-recent-searches 

                             notmuch-hello-insert-alltags)

    notmuch-show-logo nil

    notmuch-search-oldest-first nil

    notmuch-hello-hide-tags '("kill")

    notmuch-saved-searches '((:name "inbox" :query "tag:inbox" :key "i")

                             (:name "unread" :query "tag:unread" :key "u")

                             (:name "new" :query "tag:new" :key "n")

                             (:name "sent" :query "tag:sent" :key "e")

                             (:name "drafts" :query "tag:draft" :key "d")

                             (:name "all mail" :query "*" :key "a")

                             (:name "todo" :query "tag:todo" :key "t")))

   :config

   ;;;###autoload

   (defun notmuch-exec-offlineimap ()

     "execute offlineimap command and tag new mail with notmuch"

     (interactive)

     (start-process-shell-command "offlineimap"

                                  "*offlineimap*"

                                  "offlineimap -o")

     (notmuch-refresh-all-buffers))

   (defun offlineimap-get-password (host port)

     (let* ((netrc (netrc-parse (expand-file-name "~/.netrc.gpg")))

            (hostentry (netrc-machine netrc host port port)))

       (when hostentry (netrc-get hostentry "password"))))

   (defun mark-as-read ()

     "mark message as read."

     (interactive)

     (notmuch-search-tag '("-new" "-unread" "-inbox")))

   (defun mark-as-todo ()

     "mark message as todo."

     (interactive)

     (mark-as-read)

     (notmuch-search-tag '("-new" "-unread" "-inbox" "+todo")))

   (defun mark-as-spam ()

     "mark message as spam."

     (interactive)

     (mark-as-read)

     (notmuch-search-tag (list "+spam")))

   (keymap-set user-map "e m" #'notmuch)

   (keymap-set user-map "e M" #'notmuch-exec-offlineimap)

   (keymap-set notmuch-search-mode-map "S" #'mark-as-spam)

   (keymap-set notmuch-search-mode-map "R" #'mark-as-read)

   (keymap-set notmuch-search-mode-map "T" #'mark-as-todo))

 (use-package elfeed 

   :ensure t

   :custom

   elfeed-feeds 

   '(("http://threesixty360.wordpress.com/feed/" blog math)

     ("http://www.50ply.com/atom.xml" blog dev)

     ("http://blog.cryptographyengineering.com/feeds/posts/default" blog)

     ("http://abstrusegoose.com/feed.xml" comic)

     ("http://accidental-art.tumblr.com/rss" image math)

     ("http://researchcenter.paloaltonetworks.com/unit42/feed/" security)

     ("http://curiousprogrammer.wordpress.com/feed/" blog dev)

     ("http://feeds.feedburner.com/amazingsuperpowers" comic)

     ("http://amitp.blogspot.com/feeds/posts/default" blog dev)

     ("http://pages.cs.wisc.edu/~psilord/blog/rssfeed.rss" blog)

     ("http://www.anticscomic.com/?feed=rss2" comic)

     ("http://feeds.feedburner.com/blogspot/TPQSS" blog dev)

     ("http://techchrunch.com/feeds" tech news)

     ("https://rss.nytimes.com/services/xml/rss/nyt/Technology.xml" tech news)

     ("https://static.fsf.org/fsforg/rss/news.xml" tech news)

     ("https://feeds.npr.org/1001/rss.xml" news)

     ("https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=10000664" fin news)

     ("https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=19854910" tech news)

     ("https://search.cnbc.com/rs/search/combinedcms/view.xml?partnerId=wrss01&id=100003114" us news)

     ("http://arxiv.org/rss/cs" cs rnd)

     ("http://arxiv.org/rss/math" math rnd)

     ("http://arxiv.org/rss/q-fin" q-fin rnd)

     ("http://arxiv.org/rss/stat" stat rnd)

     ("http://arxiv.org/rss/econ" econ rnd)

     ;; John Wiegley

     ("http://newartisans.com/rss.xml" dev blog)

     ;; comp

     ;; ("https://lab.rwest.io/comp.atom?feed_token=pHu9qwLkjy4CWJHx9rrJ" comp vc)

     ("https://www.reddit.com/r/listentothis/.rss" music reddit)

     ("https://www.ftc.gov/feeds/press-release-consumer-protection.xml" gov ftc)

     ("https://api2.fcc.gov/edocs/public/api/v1/rss/" gov fcc)

     )

   :init

   (defun yt-dl-it (url)

     "Downloads the URL in an async shell"

     (let ((default-directory user-stash-directory))

       (async-shell-command (format "yt-dlp %s" url))))

   (defun elfeed-youtube-dl (&optional use-generic-p)

     "Youtube-DL link"

     (interactive "P")

     (let ((entries (elfeed-search-selected)))

       (cl-loop for entry in entries

                do (elfeed-untag entry 'unread)

                when (elfeed-entry-link entry)

                do (yt-dl-it it))

       (mapc #'elfeed-search-update-entry entries)

       (unless (use-region-p) (forward-line))))

   :config

   (keymap-set elfeed-search-mode-map "d" 'elfeed-youtube-dl)

   (keymap-set user-map "e f" #'elfeed)

   (keymap-set user-map "e F" #'elfeed-update))

 (use-package elfeed-tube

   :ensure t

   :after elfeed

   :config

   ;; (elfeed-tube-setup)

   (elfeed-tube-add-feeds '("detroit techno" "boiler room dj" "brad mehldau" "chris 'daddy' dave"))

   :bind (:map elfeed-show-mode-map

          ("F" . elfeed-tube-fetch)

          ([remap save-buffer] . elfeed-tube-save)

          :map elfeed-search-mode-map

          ("F" . elfeed-tube-fetch)

          ([remap save-buffer] . elfeed-tube-save)))

 (use-package elfeed-tube-mpv

   :ensure t

   :bind (:map elfeed-show-mode-map

               ("C-c C-f" . elfeed-tube-mpv-follow-mode)

               ("C-c C-w" . elfeed-tube-mpv-where)))

 (use-package org-mime :ensure t)

 (use-package sh-script

   :hook (sh-mode . flymake-mode))

 ;;; Org Config

 (setq publish-dir "/ssh:rurik:/srv/http/compiler.company")

 (keymap-set user-map "t" #'org-todo)

 ;; populate org-babel

 (org-babel-do-load-languages

  ;; TODO 2021-10-24: bqn, apl, k

  'org-babel-load-languages '((shell . t)

 			     (emacs-lisp . t)

 			     (lisp . t)

 			     (org . t)

 			     (eshell . t)

                              (calc . t)

 			     (sed . t)

 			     (awk . t)

 			     (dot . t)

 			     (js . t)

 			     (C . t)

 			     (python . t)

 			     (lua . t)

 			     (lilypond . t)))

 ;;; IRC

 (setq erc-format-nick-function 'erc-format-@nick)

 (defun start-erc ()

   "Connect to IRC."

   (interactive)

   (erc-tls :server "irc.libera.chat" :port 6697

            :client-certificate '("/mnt/y/data/private/krypt/libera.pem"))

   (setq erc-autojoin-channels-alist '(("irc.libera.chat" "#emacs")

                                       ("irc.libera.chat" "#linux")

                                       ("irc.libera.chat" "#rust")

                                       ("irc.libera.chat" "#btrfs")

                                       ("irc.libera.chat" "#lisp")

                                       ("irc.libera.chat" "#sbcl")

                                       ("irc.oftc.net" "#llvm"))))

 ;;; Tags

 ;;;###autoload

 (defun refresh-tags ()

   "Refresh TAGS database in `user-emacs-directory'."

   (interactive)

   (let ((default-directory user-emacs-directory))

     (async-shell-command 

      "etags ./*.el \\

 ./lib/*.el \\

 ~/comp/core/emacs/*.el \\

 ~/comp/core/emacs/lib/*.el \\

 -o TAGS")))

 (unless (string-equal "hyde"  system-name)

   (add-hook 'dired-mode-hook #'all-the-icons-dired-mode)

   (add-hook 'ibuffer-mode-hook #'all-the-icons-ibuffer-mode))

 ;; strangerdanger

 ;; (setq slime-enable-evaluate-in-emacs t)

 (defun org-word-count (beg end

                            &optional count-latex-macro-args?

                            count-footnotes?)

   "Report the number of words in the Org mode buffer or selected region.

 Ignores:

 - comments

 - tables

 - source code blocks (#+BEGIN_SRC ... #+END_SRC, and inline blocks)

 - hyperlinks (but does count words in hyperlink descriptions)

 - tags, priorities, and TODO keywords in headers

 - sections tagged as 'not for export'.

 The text of footnote definitions is ignored, unless the optional argument

 COUNT-FOOTNOTES? is non-nil.

 If the optional argument COUNT-LATEX-MACRO-ARGS? is non-nil, the word count

 includes LaTeX macro arguments (the material between {curly braces}).

 Otherwise, and by default, every LaTeX macro counts as 1 word regardless

 of its arguments."

   (interactive "r")

   (unless mark-active

     (setf beg (point-min)

           end (point-max)))

   (let ((wc 0)

         (latex-macro-regexp "\\\\[A-Za-z]+\\(\\[[^]]*\\]\\|\\){\\([^}]*\\)}"))

     (save-excursion

       (goto-char beg)

       (while (< (point) end)

         (cond

          ;; Ignore comments.

          ((or (org-in-commented-line) (org-at-table-p))

           nil)

          ;; Ignore hyperlinks. But if link has a description, count

          ;; the words within the description.

          ((looking-at org-bracket-link-analytic-regexp)

           (when (match-string-no-properties 5)

             (let ((desc (match-string-no-properties 5)))

               (save-match-data

                 (cl-incf wc (length (remove "" (org-split-string

                                                 desc "\\W")))))))

           (goto-char (match-end 0)))

          ((looking-at org-any-link-re)

           (goto-char (match-end 0)))

          ;; Ignore source code blocks.

          ((org-in-regexps-block-p "^#\\+BEGIN_SRC\\W" "^#\\+END_SRC\\W")

           nil)

          ;; Ignore inline source blocks, counting them as 1 word.

          ((save-excursion

             (backward-char)

             (looking-at org-babel-inline-src-block-regexp))

           (goto-char (match-end 0))

           (setf wc (+ 2 wc)))

          ;; Count latex macros as 1 word, ignoring their arguments.

          ((save-excursion

             (backward-char)

             (looking-at latex-macro-regexp))

           (goto-char (if count-latex-macro-args?

                          (match-beginning 2)

                        (match-end 0)))

           (setf wc (+ 2 wc)))

          ;; Ignore footnotes.

          ((and (not count-footnotes?)

                (or (org-footnote-at-definition-p)

                    (org-footnote-at-reference-p)))

           nil)

          (t

           (let ((contexts (org-context)))

             (cond

              ;; Ignore tags and TODO keywords, etc.

              ((or (assoc :todo-keyword contexts)

                   (assoc :priority contexts)

                   (assoc :keyword contexts)

                   (assoc :checkbox contexts))

               nil)

              ;; Ignore sections marked with tags that are

              ;; excluded from export.

              ((assoc :tags contexts)

               (if (intersection (org-get-tags-at) org-export-exclude-tags

                                 :test 'equal)

                   (org-forward-same-level 1)

                 nil))

              (t

               (cl-incf wc))))))

         (re-search-forward "\\w+\\W*")))

     (message (format "%d words in %s." wc

                      (if mark-active "region" "buffer")))))

 (defun org-check-misformatted-subtree ()

   "Check misformatted entries in the current buffer."

   (interactive)

   (show-all)

   (org-map-entries

    (lambda ()

      (when (and (move-beginning-of-line 2)

                 (not (looking-at org-heading-regexp)))

        (if (or (and (org-get-scheduled-time (point))

                     (not (looking-at (concat "^.*" org-scheduled-regexp))))

                (and (org-get-deadline-time (point))

                     (not (looking-at (concat "^.*" org-deadline-regexp)))))

            (when (y-or-n-p "Fix this subtree? ")

              (message "Call the function again when you're done fixing this subtree.")

              (recursive-edit))

          (message "All subtrees checked."))))))