Minemacs Modules

(require 'eww)
(require 'bookmark)
(defun browse-url-bookmark-jump (bookmark)
  "Bookmark jump handler: relies on =browse-url-handler= to pick the right browser.
  Define a custom jumper avoid to open always on EWW in case the bookmark was placed with it"
  (browse-url (bookmark-prop-get bookmark 'location)))
(defalias #'eww-bookmark-jump #'browse-url-bookmark-jump)

;; Enable rich annotations using the Marginalia package
(use-package marginalia
  ;; Bind `marginalia-cycle' locally in the minibuffer.  To make the binding
  ;; available in the *Completions* buffer, add it to the
  ;; `completion-list-mode-map'.
  :bind (:map minibuffer-local-map
           ("M-A" . marginalia-cycle))

  ;; The :init section is always executed.
  :init

  ;; Marginalia must be activated in the :init section of use-package such that
  ;; the mode gets enabled right away. Note that this forces loading the
  ;; package.
  (marginalia-mode))

(use-package helpful
  :bind
  ("C-h f" . #'helpful-callable)
  ("C-h v" . #'helpful-variable)
  ("C-h k" . #'helpful-key)
  ("C-h x" . #'helpful-command))

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

(defun eshell/ve (&rest args)
  (let* ((cmd (car args))
           (argv (cdr args))
           (argl (string-join argv " ")))
    (if argv (eshell-exec-visual cmd argl) (eshell-exec-visual cmd))))

set wallpaper ${random-from-list ${ls ~/Pictures/wallpapers/*}}
ln -sf $wallpaper  ~/Pictures/wallpaper
feh --bg-fill ~/Pictures/wallpaper

(use-package exec-path-from-shell
  :config
  (exec-path-from-shell-initialize))

(use-package csv)
(use-package csv-mode)
(use-package yaml-mode)

(use-package project
  :config
  (add-to-list 'project-switch-commands '(project-shell "shell")))

(use-package magit
:bind
(("C-x g" . #'magit-status)))

(use-package diff-hl
  :config
  (diff-hl-mode 1))

(use-package docker)
(use-package dockerfile-mode)
(use-package docker-compose-mode)

(use-package tabspaces
  :hook (after-init . tabspaces-mode)
  :commands (tabspaces-switch-or-create-workspace
             tabspaces-open-or-create-project-and-workspace)
  :bind
  (("s-q" . #'tab-switch)
   ("s-{" . #'tab-previous)
   ("s-}" . #'tab-next))
  :custom
  (tabspaces-keymap-prefix "C-x t w")
  (tabspaces-use-filtered-buffers-as-default t)
  (tabspaces-default-tab "Default")
  (tabspaces-remove-to-default t)
  (tabspaces-initialize-project-with-todo t)
  (tabspaces-todo-file-name "project-todo.org")
  ;; I don't want tabspaces to manage sessions, so I keep those lines commented out.
  ;; (tabspaces-session t)
  ;; (tabspaces-session-auto-restore t))
  )

(use-package yasnippet
  :custom
  (yas-snippet-dirs '("~/Dropbox/minemacs/snippets"))
  :config
  (yas-global-mode 1))

(use-package yasnippet-snippets
  :after yasnippet)

(use-package vterm
  :after god-mode
  :config
  (require 'god-mode)
  (add-to-list 'god-exempt-major-modes 'vterm-mode)

  (defun minemacs-vterm-exec (command)
    (interactive "sCommand: ")
    (let ((buffer-name (format "*vterm <%s>*" command)))
        (with-current-buffer (vterm buffer-name)
        (vterm-send-string (format "%s && exit\n" command)))))

  (defun minemacs-tmux/open ()
    (interactive)
    (minemacs-vterm-exec "tmux attach || tmux")))

curl https://cht.sh 

(defun cht.sh-help (helpable)
  (interactive "sHelp: ")
  (cht.sh-query "/:help"))

(defun cht.sh-list ()
  (interactive)
  (cht.sh-query "/:list"))

(defun cht.sh-query (query)
  (interactive "sQuery: ")
  (let ((cmd (format "curl https://cht.sh/%s" query))
        (buffer-name (format "*cht-sh* <%s>" query)))
    (async-shell-command cmd buffer-name)))

(defcustom minemacs-github-api-username nil "Your Github username (email)" :type '(string))

(defun minemacs-github-api-token ()
  (if-let* ((matched (auth-source-search :host "api.github.com" :login minemacs-github-api-username :port 80))
              (auth (car matched)))
        (funcall (plist-get auth :secret))))

(defun minemacs-github--display-repos (repos)
  (with-current-buffer (get-buffer-create "test")
    (erase-buffer)
    (seq-doseq (repo repos)
        (let ((name (gethash "full_name" repo)))
          (insert (format "=> %s\n" name))))
    (pop-to-buffer (current-buffer))))

(defun minemacs-github--fetch-repos ()
  (let* ((token-header (format "token %s" (minemacs-github-api-token)))
           (url-request-extra-headers `(
                                        ("Content-Type" . "application/json")
                                        ("Authorization" . ,token-header))))
    (with-temp-buffer
        (url-insert-file-contents "https://api.github.com/user/repos")
        (minemacs-github--display-repos (json-parse-buffer)))))

(defun minemacs-github-repos ()
  (interactive)
  (minemacs-github--fetch-repos))

(defun jarvis-scenecutter--add-scene (proc pts duration pts-time duration-time)
  (message "Adding scene pts:%s duration:%s pts-time:%s duration-time:%s" pts duration pts-time duration-time)
  (let* ((scene (list :pts pts :duration duration :pts-time pts-time :duration-time duration-time))
           (data (gethash proc jarvis-scenecutter--scenes))
           (scenes (plist-get data :scenes))
           (new-scenes (append scenes (list scene))))
    (puthash proc (plist-put data :scenes new-scenes) jarvis-scenecutter--scenes)))

(defun jarvis-scenecutter--parse-scenes (proc input)
  (when (string-match "Parsed_showinfo" input)
    (let* ((_ (string-match "pts:\s*\\([[:alnum:]\|\.]+\\)" input))
             (pts (match-string 1 input))
             (_ (string-match "duration:\s*\\([[:alnum:]\|\.]+\\)" input))
             (duration (match-string 1 input))
             (_ (string-match "pts_time:\s*\\([[:alnum:]\|\.]+\\)" input))
             (pts-time (match-string 1 input))
             (_ (string-match "duration_time:\s*\\([[:alnum:]\|\.]+\\)" input))
             (duration-time (match-string 1 input)))
        (and pts duration pts-time duration-time
             (jarvis-scenecutter--add-scene proc
                                            (string-to-number pts)
                                            (string-to-number duration)
                                            (string-to-number pts-time)
                                            (string-to-number duration-time))))))

(defun jarvis-scenecutter--create-scene-async (file scene index)
  (let* ((name (file-name-sans-extension (file-name-base file)))
           (ext (file-name-extension file))
           (scenes-dir (file-name-sans-extension file))
           (scene-file (file-name-concat scenes-dir (format "%s-scene-%s.%s" name index ext)))
           (start (plist-get scene :pts))
           (duration (plist-get scene :duration))
           (cmd
            (format
             "ffmpeg -i %s -ss %s -t %s %s"
             file start duration scene-file)))
    (message "Creating scene via: %s" cmd)
    ;;(mkdir scenes-dir t)
    ;;(call-process-shell-command cmd nil 0)))
    ))

(defun jarvis-scenecutter--create-scene-thumb (file thumb-seek thumb-file)
  (let* ((cmd (format "ffmpeg -i %s -ss %sms -frames:v 1 %s" file thumb-seek thumb-file))
           (thumb-width 660)
           (thumb-org-code (format "#+ATTR_HTML: width=\"%spx\"\n#+ATTR_ORG: :width %s\n[[%s]]\n" thumb-width thumb-width thumb-file))
           (proc (make-process
                  :name thumb-file
                  :command (list "ffmpeg" "-i" file "-ss" (format "%sms" thumb-seek) "-frames:v" "1" thumb-file)
                  :buffer nil
                  :sentinel (lambda (proc event)
                              (and (equal "finished\n" event)
                                   (let* ((entry (minemacs-cache-get proc))
                                          (buffer (car entry))
                                          (point (cdr entry)))
                                     (when buffer (with-current-buffer buffer (org-redisplay-inline-images) (goto-char point)))
                                     ;; remove cache entry
                                     ))))))
    (minemacs-cache-set proc (cons (current-buffer) (point)))
    thumb-org-code))

(defun jarvis-scenecutter--create-scenes-thumbs (file scenes thumb-files-template)
  (let* ((scenes-params (string-join (cons "eq(n\\,0)" (mapcar (lambda (scene) (format "eq(n\\,%d)" (plist-get scene :pts))) scenes)) "+"))
           (cmd (list "ffmpeg" "-i" file "-vf" (format "select='%s'" scenes-params) "-frame_pts" "1" "-vsync" "0" thumb-files-template))
           (proc (make-process
                  :name (format "scenecutter-%s" file)
                  :command cmd
                  :buffer nil
                  :sentinel (lambda (proc event)
                              (and (equal "finished\n" event)
                                   (let ((buffer (minemacs-cache-get proc)))
                                     (when buffer (with-current-buffer buffer (org-redisplay-inline-images)))
                                     ;; remove cache entry
                                     ))))))
    (minemacs-cache-set proc (current-buffer))))

(defun jarvis-scenecutter--create-scenes-index (file scenes)
  (let* ((default-directory (file-name-directory file))
           (name (file-name-sans-extension (file-name-base file)))
           (scenes-index-file (file-name-concat default-directory (format "%s-scenes.org" name)))
           (buffer (find-file-noselect scenes-index-file))
           (title (format "%s scenes index" name))
           (thumb-width 660))
    (with-current-buffer buffer
        (jarvis-scenecutter--create-scenes-thumbs file scenes (format "%s-scene-%%d.png" name))
        (erase-buffer)
        (insert "# -*- org-image-actual-width: nil; eval: (org-display-inline-images); -*-\n")
        (insert (format "#+TITLE: %s\n#+STARTUP: content\n\n" title))
        (insert (format "* Scenes for %s\n\n" file))
        (let ((first-scene (car scenes))
              (reduce-fun (lambda (prev-scene scene)
                            (let* ((seek-start (plist-get prev-scene :pts))
                                   (seek-end (plist-get scene :pts))
                                   (thumb-seek (+ seek-start 10))
                                   (scene-file (file-name-concat default-directory (format "%s-scene-%s.mp4" name seek-start)))
                                   (thumb-file (file-name-concat default-directory (format "%s-scene-%s.png" name seek-start))))
                              ;; (insert (format "%s\n\n" (prin1-to-string scene)))
                              (insert (format "** %s -- %s\n\n" seek-start seek-end))

                              (insert "#+begin_src emacs-lisp :results output raw replace\n")
                              (insert (format "(jarvis-scenecutter--create-scene-thumb \"%s\" %s \"%s\")\n" file seek-start thumb-file))
                              (insert "#+end_src\n\n")

                              (insert (format "#+RESULTS:\n#+ATTR_HTML: width=\"%spx\"\n#+ATTR_ORG: :width %s\n[[%s]]\n\n" thumb-width thumb-width thumb-file))

                              (insert "#+begin_src sh :results silent\n")
                              (insert (format "ffmpeg -y -accurate_seek -i %s -ss %sus -to %sus %s\n" file seek-start seek-end scene-file))
                              (insert "#+end_src\n\n")
                              scene))))
          (seq-reduce reduce-fun scenes (list :pts 0)))
        (basic-save-buffer)
        (beginning-of-buffer)
        (pop-to-buffer buffer))))

(defun jarvis-scenecutter--cache-key (file)
  (file-name-sans-extension (file-name-base (expand-file-name file))))

(defun jarvis-scenecutter--cache-scenes-load (file)
  (minemacs-cache-get (jarvis-scenecutter--cache-key file) :jarvis-scenecutter))

(defun jarvis-scenecutter--cache-scenes-save (file data)
  (minemacs-cache-set (jarvis-scenecutter--cache-key file) data :jarvis-scenecutter))

(defun jarvis-scenecutter--process-scenes (file scenes)
  (message "Processing scenes for %s" file)
  (jarvis-scenecutter--create-scenes-index file scenes)
  ;; (seq-do-indexed
  ;;  (lambda (scene index)
  ;;    (jarvis-scenecutter--create-scene-async file scene index))
  ;;  scenes))
  )

(defun jarvis-scenecutter--sentinel (proc event)
  (when (string= event "finished\n")
    (with-current-buffer (process-buffer proc)
        (let* ((data (gethash proc jarvis-scenecutter--scenes))
               (file (plist-get data :file))
               (scenes (plist-get data :scenes)))
          (message "Finished extraction for %s" file)
          (message "extracted %s scenes" (length scenes))
          (jarvis-scenecutter--cache-scenes-save file data))
          (jarvis-scenecutter--process-scenes file scenes)
        (remhash proc jarvis-scenecutter--scenes)
        (kill-current-buffer))))

(defvar jarvis-scenecutter--scenes (make-hash-table))

(defun jarvis-scenecutter--extract-scenes (file)
  (message "Started extraction for %s" file)
  (with-current-buffer (generate-new-buffer "*jarvis-scenecutter*")
    (let* ((pathname (expand-file-name file))
             (cmd (list "ffmpeg" "-i" pathname "-vf" "select='gt(scene,0.4)',showinfo" "-f" "null" "-"))
             (proc (make-process
                    :name pathname
                    :buffer (current-buffer)
                    :command cmd
                    :filter #'jarvis-scenecutter--parse-scenes
                    :sentinel #'jarvis-scenecutter--sentinel)))
        (puthash proc (list :file pathname :scenes '()) jarvis-scenecutter--scenes))))

(defun jarvis-scenecutter (file)
  (interactive "fFile: ")
  (let ((data (jarvis-scenecutter--cache-scenes-load file)))
    (if data
          (let ((file (plist-get data :file))
                (scenes (plist-get data :scenes)))
            (jarvis-scenecutter--process-scenes file scenes))
        (jarvis-scenecutter--extract-scenes file))))

(defun jarvis/espeak (text)
  "Speak text using `espeak`."
  (interactive (list
                (completing-read "Text: " nil nil nil (buffer-substring-no-properties (mark) (point)))))
  (save-window-excursion
    (async-shell-command (format "espeak -v it \"%s\"" text) nil)))

// ==UserScript==
// @name         Bifrost-HTTP
// @namespace    http://minasmazar.github.io/bifrost
// @version      0.3
// @description  Bifrost is a userscript to bridge your Browser and an Elixir app.
// @author       minasmazar@gmail.com
// @include      *
// @icon         https://www.google.com/s2/favicons?sz=64&domain=undefined.localhost
// @grant        GM_xmlhttpRequest
// @grant        GM.xmlHttpRequest
// @grant        GM_openInTab
// @connect      localhost
// ==/UserScript==

window.bifrostCircularReplacer = function() {
  const seen = new WeakSet();
  return (key, value) => {
    if (typeof value === "object" && value !== null) {
        if (seen.has(value)) {
          return;
        }
        seen.add(value);
    }
    return value;
  };
};

window.bifrostSend = function(message) {
  const payload = JSON.stringify({ "id": window.bifrostPageId, "location": window.location, "message": message }, window.bifrostCircularReplacer());
  console.log(`Sending : ${message}`);
  GM.xmlHttpRequest({
    method: "POST",
    url: "http://localhost:9096/bifrost",
    data: message,
    headers: {
        "Content-Type": "application/x-www-form-urlencoded"
    },
    onload: function(response) {
        console.log("Received response");
    },
    onerror: function(response) {
        console.log("Error");
    }
  });
};

window.bifrostOpenInTab = function(url, openInBackground = true) {
  //window.open(url, "_blank");
  GM_openInTab(url, openInBackground);
};

window.bifrostSetup = function() {
  window.bifrostPageId = crypto.randomUUID();
  window.bifrostEventHandler = function(event) {
    const payload = {
        "event": {
          "type": event.type,
          "tag": event.target.tagName,
          "class": event.target.className,
          "id": event.target.id,
          "text": event.target.innerText,
          "value": event.target.value
        }
    };
    // console.log(payload);
    window.bifrostSend(payload);
  };
  document.addEventListener("click", window.bifrostEventHandler);
  document.addEventListener("change", window.bifrostEventHandler);
  document.addEventListener("input", window.bifrostEventHandler);

  const links = [...document.querySelectorAll("a")].flatMap(el => el.href);
  window.bifrostSend({"links": links});
};

window.addEventListener("load", window.bifrostSetup);

(use-package web-server
  :init
  (defcustom bifrost-active t "Wether bifrost is going to handle requests or not." :type '(boolean))
  (defvar bifrost-request-hooks nil "Hooks invoked when Bifrost request is received.")
  :hook
  (bifrost-request-hooks . (lambda (_request _dom)
                               (pop-to-buffer "*bifrost*")))
  :config
  (require 'web-server)

  (defun bifrost--request-handler (request)
    (when bifrost-active
        (with-current-buffer (get-buffer-create "*bifrost*" t)
          (let ((inhibit-read-only t))
            (erase-buffer)
            (with-slots (body) request (insert body))
            (beginning-of-buffer))
          (setq bifrost--last-request request)
          (let* ((json (json-parse-buffer))
                 (location (gethash "location" json))
                 (url (getash "href" location))
                 (message (gethash "message" json)))
          (run-hook-with-args 'bifrost-request-hooks url message)))))

  (defun bifrost-server-start ()
    "Start bifrost server."
    (interactive)
    (setq bifrost--server
            (ws-start
             '(((:POST . ".*") .
                (lambda (request)
                  (with-slots (process headers body) request
                    (let ((message (cdr (assoc "message" headers))))
                      (ws-response-header process 200 '("Content-type" . "text/plain"))
                      (setq bifrost--last-request request)
                      (bifrost--request-handler request))))))
             9096)))

  (when bifrost-active (bifrost-server-start)))

(use-package all-the-icons)
(use-package all-the-icons-gnus
  :config
  (all-the-icons-gnus-setup))
(use-package all-the-icons-dired
  :hook
  (dired-mode . all-the-icons-dired-mode))
(use-package all-the-icons-ibuffer
  :hook
  (ibuffer-mode . all-the-icons-ibuffer-mode))

(use-package dashboard
  :config
  (dashboard-setup-startup-hook)
  :bind
  (:map dashboard-mode-map
        ("n" . #'widget-forward)
        ("p" . #'widget-backward))
  :custom
  (dashboard-week-agenda t)
  (dashboard-icon-type 'all-the-icons)
  (dashboard-set-file-icons t)
  (dashboard-set-heading-icons t)
  (dashboard-navigation-cycle t)
  (dashboard-items '((recents   . 5)
                     (bookmarks . 5)
                     (projects  . 5)
                     (agenda    . 5)
                     (registers . 5)))
  (dashboard-item-shortcuts '((recents   . "r")
                              (bookmarks . "m")
                              (projects  . "p")
                              (agenda    . "a")
                              (registers . "e"))))

(use-package org-modern
  :config
  (global-org-modern-mode))

(set-frame-parameter nil 'alpha-background 85)

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

(use-package ef-themes
  :config
  (defun get-season (month)
    (cond
     ((and (>= month 3) (< month 6)) 'spring)
     ((and (>= month 6) (< month 9)) 'summer)
     ((and (>= month 10) (< month 12)) 'autumn)
     ((or (>= month 12) (< month 3)) 'winter)))

  (defun set-season-theme ()
    (interactive)
    (let* ((month (car (calendar-current-date)))
           (season (get-season month))
           (theme-name (format "ef-%s" season)))
      (load-theme (intern theme-name)))))

(use-package doom-modeline
  :hook (after-init . doom-modeline-mode))

(defcustom minemacs-headline-content ""
  "Content of the headline."
  :type 'string)
(setq header-line-format '((:eval minemacs-headline-content)))

(use-package engine-mode
  :init
  (setq engine/browser-function #'browse-url-firefox)
  :config
  (defun engine/execute-search (search-engine-url browser-function search-term)
    "Display the results of the query."
    (interactive)
    (let ((browse-url-handlers nil)
            (browse-url-browser-function browser-function))
        (browse-url
         (format-spec search-engine-url
                      (format-spec-make ?s (url-hexify-string search-term))))))

  (defengine dropbox
    "https://www.dropbox.com/search/personal?query=%s"
    :browser 'browse-url-firefox
    :keybinding "D")

  (defengine duckduckgo
    "https://duckduckgo.com/?q=%s"
    :browser 'eww-browse-url
    :keybinding "d")

  (defengine github
    "https://github.com/search?ref=simplesearch&q=%s"
    :keybinding "h")

  (defengine google
    "http://www.google.com/search?ie=utf-8&oe=utf-8&q=%s"
    :browser 'browse-url-firefox
    :keybinding "g")

  (defengine google-images
    "http://www.google.com/images?hl=en&source=hp&biw=1440&bih=795&gbv=2&aq=f&aqi=&aql=&oq=&q=%s"
    :keybinding "i")

  (defengine google-maps
    "https://maps.google.com/maps?q=%s"
    :docstring "Google Maps"
    :browser 'browse-url-firefox
    :keybinding "m")

  (defengine openstreet-maps
    "https://www.openstreetmap.org/search?query=%s"
    :docstring "OpenStreetMap"
    :keybinding "M")

  (defengine google-translate-to-it
    "http://translate.google.it/?sl=auto&tl=it&text=%s&op=translate"
    :docstring "Translate to IT"
    :keybinding "t")

  (defengine google-translate-to-en
    "http://translate.google.it/?sl=it&tl=en&text=%s&op=translate"
    :docstring "Translate from IT to English"
    :browser 'browse-url-firefox
    :keybinding "T")

  (defengine stack-overflow
    "https://stackoverflow.com/search?q=%s"
    :keybinding "s")

  (defengine wikipedia
    "https://www.wikipedia.org/search-redirect.php?language=it&go=Go&search=%s"
    :keybinding "w"
    :docstring "Searchin' the wikis."
    :browser 'eww-browse-url)

  (defengine youtube
    "http://www.youtube.com/results?aq=f&oq=&search_query=%s"
    :keybinding "y")

  (defengine amazon
    "https://www.amazon.it/s/ref=nb_sb_noss?&field-keywords=%s"
    :browser 'browse-url-firefox
    :keybinding "a")

  (defengine cap
    "https://www.nonsolocap.it/cap?k=%s&c=pescara"
    :browser 'browse-url-firefox
    :keybinding "C")

  (engine-mode t))

  (defun browse-url-firefox-private (url)
    "Ask the Firefox WWW browser to load URL.
Same as `browse-url-firefox', but sets `browse-url-firefox-arguments'."
    (interactive "sURL: ")
    (let ((browse-url-firefox-arguments (list "--private-window")))
      (funcall-interactively #'browse-url-firefox url)))

(use-package elpher)
(use-package gemini-mode)

(use-package walkman)
(use-package restclient)

(use-package bongo
  :bind
  (:map dired-mode-map
          (("b a" . #'bongo-dired-append-enqueue-lines))))

(use-package yeetube
  :bind
  (:map minemacs-map
        ("m y s" . #'yeetube-search)
        ("m y es" . #'empv-youtube)))

(use-package ytdl
  :bind
  (:map minemacs-map ("m y d" . #'ytdl-download)))

  (use-package pulseaudio-control
    :after hydra
    :defer t
    :config
    (defhydra hydra-pulseaudio-control (:color amaranth)
        "
Control audio (pulseaudio)
🔊 [n] decrease | 🔉 [_p_] decrease | 🔇 _m_ute == _q_uit
"
        ("p" (lambda () (interactive) (pulseaudio-control-increase-sink-volume 5)) nil)
        ("n" (lambda () (interactive) (pulseaudio-control-decrease-sink-volume 5)) nil)
        ("m" (lambda () (interactive) (pulseaudio-control-toggle-current-sink-mute)) nil)		       
        ("q" nil nil))
    :bind
    (:map minemacs-map (("m v" . hydra-pulseaudio-control/body))))

(use-package elfeed
  :after 'god-mode
  :bind*
  (:map elfeed-search-mode-map ("U" . (lambda () (interactive) (run-at-time "10min" t #'elfeed-update))))
  :init
  (add-to-list 'god-exempt-major-modes 'elfeed-search-mode-map)
  (add-to-list 'god-exempt-major-modes 'elfeed-show-mode-map))

(use-package elfeed-tube
  :after elfeed
  :demand t
  :config
  ;; (setq elfeed-tube-auto-save-p nil) ; default value
  ;; (setq elfeed-tube-auto-fetch-p t)  ; default value
  (elfeed-tube-setup)

  :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
  :after elfeed-tube
  :bind (:map elfeed-show-mode-map
                ("v" . #'elfeed-tube-mpv)
                ("C-c C-f" . elfeed-tube-mpv-follow-mode)
                ("C-c C-w" . elfeed-tube-mpv-where)))

(use-package elfeed-org)

(let* ((feeds nil))
  (with-elfeed-db-visit (entry feed)
    (add-to-list 'feeds feed)
    (when (equal (length feeds) 1)
        (elfeed-db-return (list :ok feeds)))))

(use-package password-store)

(use-package alarm-clock)

(defun minemacs-exwm-enabled? ()
  (equal (getenv "EXWM") "true"))

(use-package vertico-posframe
  :if (minemacs-exwm-enabled?)
  :config
  (vertico-posframe-mode 1))

(use-package pulseaudio-control)

(use-package exwm
  :if (minemacs-exwm-enabled?)
  :init
  ;; (start-process "dex" nil "dex" "-a" "-e" "i3")
  ;; (start-process "power-manager" nil "xfce4-power-manager")
  ;; (start-process "xfce-settings" nil "xfsettingsd")
  :bind
  (:map key-translation-map
          ("s-m" . nil)
          ("s-M" . nil))
  :config
  (server-mode 1)
  (display-battery-mode 1)

  (global-set-key (kbd "<XF86AudioLowerVolume>") #'pulseaudio-control-decrease-sink-volume)
  (global-set-key (kbd "<XF86AudioRaiseVolume>") #'pulseaudio-control-increase-sink-volume)
  (global-set-key (kbd "<XF86AudioMute>") #'pulseaudio-control-toggle-current-sink-mute)
  (global-set-key (kbd "<XF86AudioPlay>") #'minemacs-media-toggle-pause)

  (require 'exwm)
  (setq exwm-workspace-number 1)
  ;; Make class name the buffer name.
  (add-hook 'exwm-update-class-hook
              (lambda () (exwm-workspace-rename-buffer exwm-class-name)))
  ;; Global keybindings.
  (setq exwm-systemtray-height 25
          exwm-input-global-keys
          `(([?\s-k] . execute-extended-command)
            ([?\s-m] . exwm-reset)
            ([?\s-M] . exwm-input-release-keyboard)
            ([?\s-\]] . next-buffer)
            ([?\s-\[] . previous-buffer)
            ([?\s-`] . other-frame)))

  (setq exwm-input-simulation-keys
          '(([?\C-b] . [left])
            ([?\C-f] . [right])
            ([?\C-p] . [up])
            ([?\C-n] . [down])
            ([?\C-a] . [home])
            ([?\C-e] . [end])
            ([?\M-v] . [prior])
            ([?\C-v] . [next])
            ([?\C-d] . [delete])
            ([?\C-k] . [S-end delete])))

  (exwm-enable)
  (require 'exwm-systemtray)
  (exwm-systemtray-mode 1))