Sacha Chua's Emacs configuration

(unless (assoc-default "melpa" package-archives)
  (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t))
(unless (assoc-default "nongnu" package-archives)
  (add-to-list 'package-archives '("nongnu" . "https://elpa.nongnu.org/nongnu/") t))

  (setq package-review-policy t
        package-review-diff-command '("git" "diff" "--no-index" "--color=never" "--diff-filter=d"))
  (add-to-list 'display-buffer-alist
               '("\\`\\*Package Review Diff:"
                 (display-buffer-full-frame)))

(add-to-list 'load-path "~/elisp")
(setq use-package-verbose t)
(setq use-package-always-ensure t)
(require 'use-package)
(use-package quelpa)
(use-package quelpa-use-package)
(quelpa-use-package-activate-advice)
(setq load-prefer-newer t)

  (setq backup-directory-alist '(("\\.env$" . nil)
                                                                                                                           ("." . "~/.config/emacs/backups")))
  (with-eval-after-load 'tramp
          (setq tramp-backup-directory-alist nil))
  (setq delete-old-versions -1)
  (setq version-control t)
  (setq auto-save-file-name-transforms '((".*" "~/.config/emacs/auto-save-list/" t)))

(defvar backup-walker-data-alist)
(declare-function diff-no-select "diff" (old new &optional switches noasync bufname))
(declare-function backup-walker-get-version "backup-walker")
;;;###autoload
(defun sacha-backup-walker-refresh ()
  (let* ((index (cdr (assq :index backup-walker-data-alist)))
         (suffixes (cdr (assq :backup-suffix-list backup-walker-data-alist)))
         (prefix (cdr (assq :backup-prefix backup-walker-data-alist)))
         (right-file (concat prefix (nth index suffixes)))
         (right-version (format "%i" (backup-walker-get-version right-file)))
         diff-buf left-file left-version)
    (if (eq index 0)
        (setq left-file (cdr (assq :original-file backup-walker-data-alist))
              left-version "orig")
      (setq left-file (concat prefix (nth (1- index) suffixes))
            left-version (format "%i" (backup-walker-get-version left-file))))
    ;; we change this to go the other way here
    (setq diff-buf (diff-no-select right-file left-file nil 'noasync))
    (setq buffer-read-only nil)
    (delete-region (point-min) (point-max))
    (insert-buffer-substring diff-buf)
    (set-buffer-modified-p nil)
    (setq buffer-read-only t)
    (force-mode-line-update)
    (setq header-line-format
          (concat (format "{{ ~%s~ → ~%s~ }} "
                          (propertize left-version 'face 'font-lock-variable-name-face)
                          (propertize right-version 'face 'font-lock-variable-name-face))
                  (if (nth (1+ index) suffixes)
                      (concat (propertize "<p>" 'face 'italic)
                              " ~"
                              (propertize (int-to-string
                                           (backup-walker-get-version (nth (1+ index) suffixes)))
                                          'face 'font-lock-keyword-face)
                              "~ ")
                    "")
                  (if (eq index 0)
                      ""
                    (concat (propertize "<n>" 'face 'italic)
                            " ~"
                            (propertize (int-to-string (backup-walker-get-version (nth (1- index) suffixes)))
                                        'face 'font-lock-keyword-face)
                            "~ "))
                  (propertize "<return>" 'face 'italic)
                  " open ~"
                  (propertize (propertize (int-to-string (backup-walker-get-version right-file))
                                          'face 'font-lock-keyword-face))
                  "~"))
    (kill-buffer diff-buf)))

  (with-eval-after-load 'backup-walker
    (advice-add 'backup-walker-refresh :override #'sacha-backup-walker-refresh))

  (use-package backup-walker
          :vc (:url "https://github.com/lewang/backup-walker")
          :commands backup-walker-start
          :init
          (defalias 'string-to-int 'string-to-number)  ; removed in 26.1
          (defalias 'display-buffer-other-window 'display-buffer))

;;;###autoload
  (defun sacha-org-link-qr (url)
          "Display a QR code for URL in a buffer."
          (let ((buf (save-window-excursion (qrencode--encode-to-buffer (sacha-org-stored-link-as-url url)))))
                  (if (> (frame-width) 80)
                                  (display-buffer-in-side-window buf '((side . right)))
                          (display-buffer buf))))

  (use-package qrencode
          :defer t
          :commands qrencode--encode-to-buffer
          :config
          (with-eval-after-load 'embark-org
                  (define-key embark-org-link-map (kbd "q") #'sacha-org-link-qr)))

;;;###autoload
(defun sacha-embark-video ()
  "Match video."
  (let ((extensions "youtu\\.?be\\|\\(webm\\|mp4\\|flv\\)$"))
    (if-let ((link (and (derived-mode-p 'org-mode)
                        (org-element-context))))
        (when (eq (org-element-type link) 'link)
          (cond
           ((string-match extensions (org-element-property :path link))
            (cons 'video (org-element-property :path link)))))
      (when (and (derived-mode-p 'dired-mode)
                 (string-match extensions (dired-get-filename)))
        (cons 'video (dired-get-filename))))))

  (with-eval-after-load 'embark
          (add-to-list 'embark-target-finders 'sacha-embark-video)
          (defvar-keymap sacha-embark-video-actions
                  :doc "video"
                  "d" #'sacha-deepgram-recognize-audio
                  "$" #'sacha-deepgram-cost
                  "m" #'mpv-play
                  "c" #'sacha-caption-show
                  "w" #'sacha-audio-text
                  "W" #'waveform-show)
          (add-to-list 'embark-keymap-alist '(video . sacha-embark-video-actions)))

;;;###autoload
(defun sacha-embark-audio ()
  "Match audio."
  (let ((extensions "m4a\\|mp3\\|wav\\|ogg\\|opus"))
    (if-let ((link (and (derived-mode-p 'org-mode)
                        (org-element-context))))
        (when (eq (org-element-type link) 'link)
          (cond
           ((string-match extensions (org-element-property :path link))
            (cons 'audio (org-element-property :path link)))))
      (when (and (derived-mode-p 'dired-mode)
                 (string-match extensions (dired-get-filename)))
        (cons 'audio (dired-get-filename))))))

;;;###autoload
(defun sacha-audio-text (file &optional insert)
  "Get the text for FILE audio.
  If called interactively, copy to the kill ring."
  (interactive (list (read-file-name "Audio: ")))
  (let (text)
    (cond
     ((file-exists-p (concat (file-name-sans-extension file) ".txt"))
      (with-temp-buffer
        (insert-file-contents (concat (file-name-sans-extension file) ".txt"))
        (setq text (buffer-string))))
     ;; no txt yet, is there a vtt?
     ((file-exists-p (concat (file-name-sans-extension file) ".vtt"))
      (setq text (subed-subtitle-list-text
                  (subed-parse-file (concat (file-name-sans-extension file) ".vtt")))))
     ;; no VTT, let's recognize it
     (t
      (sacha-deepgram-recognize-audio file)
      (when (file-exists-p (concat (file-name-sans-extension file) ".vtt"))
        (setq text (subed-subtitle-list-text
                    (subed-parse-file (concat (file-name-sans-extension file) ".vtt")))))))
    (when text
      (when (called-interactively-p 'any)
        (if insert
            (insert text "\n")
          (kill-new text)))
      text)))

;;;###autoload
(defun sacha-open-in-audacity (file)
  (interactive "FFile: ")
  (start-process "audacity" nil "audacity" file))

(with-eval-after-load 'embark
  (add-to-list 'embark-target-finders 'sacha-embark-audio)
  (defvar-keymap sacha-embark-audio-actions
    :doc "audio"
    "a" #'sacha-open-in-audacity
    "d" #'sacha-deepgram-recognize-audio
    "$" #'sacha-deepgram-cost
    "D" #'sacha-audio-braindump-reprocess
    "m" #'mpv-play
    "w" #'sacha-audio-text
    "W" #'waveform-show)
  (add-to-list 'embark-keymap-alist '(audio . sacha-embark-audio-actions)))

;;;###autoload
(defun sacha-insert-file-as-org-include (file)
  (interactive "fFile: ")
  (set-text-properties 0 (length file) nil file)
  (let ((mode (assoc-default file auto-mode-alist 'string-match)))
    (insert
     (org-link-make-string (concat "file:" file) (concat "Download " (file-name-nondirectory file))) "\n"
     "#+begin_my_details " (file-name-nondirectory file) "\n"
     (format "#+INCLUDE: %s" (prin1-to-string file))
     (if mode
         (concat " src " (replace-regexp-in-string "-mode$" "" (symbol-name mode)))
       "")
     "\n"
     "#+end_my_details\n")))

;;;###autoload
(defun sacha-transform-org-link-to-include ()
  (interactive)
  (let ((link (org-element-lineage (org-element-context) '(link) t))
        (mode (assoc-default (org-element-property :path link) auto-mode-alist 'string-match)))
    (when link
      (delete-region (org-element-property :begin link)
                     (org-element-property :end link))
      (sacha-insert-file-as-org-include (org-element-property :path link)))))

(with-eval-after-load 'embark
  (define-key embark-file-map "O" #'sacha-insert-file-as-org-include))

;;;###autoload
(defun sacha-embark-org-element ()
  "Target an Org Mode element at point."
  (save-window-excursion
    (save-excursion
      (save-restriction
        (when (derived-mode-p 'org-agenda-mode)
          (org-goto-marker-or-bmk (org-get-at-bol 'org-marker))
          (org-back-to-heading))
        (when (derived-mode-p 'org-mode)
          (let* ((context ;; Borrowed from org-open-at-point
                  ;; Only consider supported types, even if they are not the
                  ;; closest one.
                  (org-element-lineage (org-element-context)
                                       '(headline src-block link) t))
                 (type (org-element-type context))
                 (value (org-element-property :value context)))
            (cond ((eq type 'headline)
                   (cons 'org-heading (org-element-property :title context)))
                  ;; src-block and link can be handled by embark-org
                  )))))))

;;;###autoload
(defun sacha-embark-org-src-block-copy-noweb-reference (element)
  (kill-new (if (org-element-property element :parameters)
                (format "<<%s(%s)>>" (org-element-property element :name)
                        (org-element-property element :parameters))
              (format "<<%s>>" (org-element-property element :parameters)))))

(with-eval-after-load 'embark-org
  (keymap-set embark-org-src-block-map "N" #'sacha-embark-org-src-block-copy-noweb-reference))

;;;###autoload
(defun embark-which-key-indicator ()
  "An embark indicator that displays keymaps using which-key.
  The which-key help message will show the type and value of the
  current target followed by an ellipsis if there are further
  targets."
  (lambda (&optional keymap targets prefix)
    (if (null keymap)
        (which-key--hide-popup-ignore-command)
      (which-key--show-keymap
       (if (eq (plist-get (car targets) :type) 'embark-become)
           "Become"
         (format "Act on %s '%s'%s"
                 (plist-get (car targets) :type)
                 (embark--truncate-target (plist-get (car targets) :target))
                 (if (cdr targets) "…" "")))
       (if prefix
           (pcase (lookup-key keymap prefix 'accept-default)
             ((and (pred keymapp) km) km)
             (_ (key-binding prefix 'accept-default)))
         keymap)
       nil nil t (lambda (binding)
                   (not (string-suffix-p "-argument" (cdr binding))))))))

;;;###autoload
(defun embark-hide-which-key-indicator (fn &rest args)
  "Hide the which-key indicator immediately when using the completing-read prompter."
  (which-key--hide-popup-ignore-command)
  (let ((embark-indicators
         (remq #'embark-which-key-indicator embark-indicators)))
    (apply fn args)))

(setq embark-indicators
      '(embark-which-key-indicator
        embark-highlight-indicator
        embark-isearch-highlight-indicator))

(with-eval-after-load 'embark
  (advice-add #'embark-completing-read-prompter
              :around #'embark-hide-which-key-indicator))

;;;###autoload
(defun sacha-sketch-insert-file-as-link (f)
  (interactive (list (sacha-complete-sketch-filename)))
  (cond
   ((derived-mode-p 'org-mode)
    (insert (org-link-make-string (concat "sketch:" (file-name-nondirectory f))) "\n"))
   ((or (derived-mode-p 'html-mode) (derived-mode-p 'web-mode))
    (insert "{% sketchFull \"" (file-name-base f) "\" %}"))
   (t (insert f))))

;;;###autoload
(defun sacha-embark-image ()
  "Match images."
  (let ((extensions "\\(png\\|jpg\\|svg\\|gif\\|jpeg\\)\\'"))
    (cond
     ((derived-mode-p 'org-mode)
      (when-let* ((link (org-element-context)))
        (when (eq (org-element-type link) 'link)
          (cond
           ((string= "attachment" (org-element-property :type link))
            (cons 'image (expand-file-name (org-element-property :path link)
                                           (org-attach-dir))))
           ((string-match "sketch" (org-element-property :type link))
            (cons 'image (sacha-get-sketch-filename (org-element-property :path link))))
           ((string-match extensions (org-element-property :path link))
            (cons 'image (org-element-property :path link)))))))
     ((and (derived-mode-p 'dired-mode)
           (string-match extensions (dired-get-filename)))
      (cons 'image (dired-get-filename)))
     ((derived-mode-p 'subed-mode)
      (when-let* ((filename (thing-at-point 'filename)))
        (when (string-match (concat "file:\\(.+\\." extensions "\\)") filename)
          (cons 'image (match-string 1 filename)))))
     ((and (buffer-file-name)
           (string-match extensions (buffer-file-name)))
      (cons 'image (buffer-file-name))))))
  (with-eval-after-load 'embark
          (add-to-list 'embark-target-finders 'sacha-embark-image))

;;;###autoload
(defun sacha-image-open-in-annotator (file)
  (interactive "FImage: ")
  (start-process "annotator" nil "com.github.phase1geo.annotator" (expand-file-name file)))

;;;###autoload
(defun sacha-image-open-in-krita (file)
  (interactive "FImage: ")
  (start-process "krita" nil "krita" "--nosplash" (expand-file-name file)))

;;;###autoload
(defun sacha-image-open-in-inkscape (file)
  (interactive "FImage: ")
  (start-process "inkscape" nil "inkscape" (expand-file-name file)))

;;;###autoload
(defun sacha-image-open-in-gimp (file)
  (interactive "FImage: ")
  (start-process "gimp" nil "gimp" (expand-file-name file)))

;;;###autoload
(defun sacha-open-in-firefox (file)
  (interactive "FItem: ")
  (start-process "firefox" nil "firefox" (if (string-match "^http" file) file (expand-file-name file))))

(defvar sacha-image-autocrop-border 10)

;;;###autoload
(defun sacha-image-autocrop (filename &optional border)
  (interactive "FFile: ")
  (setq border (or border sacha-image-autocrop-border))
  (let ((args (append '("-trim")
                      (if border `("-bordercolor" "#FFFFFF" "-border" ,(number-to-string border)))
                      (list "+repage" (expand-file-name filename)))))
    (apply #'call-process "mogrify" nil sacha-debug-buffer nil args)
    filename))

;;;###autoload
(defun sacha-image-recognize (file)
  "Returns the text."
  (interactive "FFile: ")
  (if (file-exists-p (concat (file-name-sans-extension file) ".txt"))
      (with-temp-buffer
        (insert-file-contents (concat (file-name-sans-extension file) ".txt"))
        (buffer-string))
    (let* ((data
            (json-parse-string
             (if (file-exists-p (concat (file-name-sans-extension file) ".json"))
                 (with-temp-buffer
                   (insert-file-contents (concat (file-name-sans-extension file) ".json"))
                   (buffer-string))
               (when (string= (file-name-extension file) "pdf")
                 (setq file (sacha-sketch-convert-pdf file)))
               (when (string= (file-name-extension file) "svg")
                 (call-process "inkscape" nil sacha-debug-buffer nil "--export-type=png" "--export-dpi=96" "--export-background-opacity=1" "--pdf-poppler" (expand-file-name file)))
               (catch 'done
                 (dolist (ext '(".png" ".jpg" ".jpeg"))
                   (when (file-exists-p (concat (file-name-sans-extension file) ext))
                     (with-temp-file (concat (file-name-sans-extension file) ".json")
                       (call-process "gcloud" nil t nil "ml" "vision" "detect-document"
                                     (expand-file-name (concat (file-name-sans-extension file) ext)))
                       (throw 'done (buffer-string)))))))
             :object-type 'alist))
           (text
            (if (assoc-default 'responses data)
                (assoc-default 'text (assoc-default 'fullTextAnnotation (elt (assoc-default 'responses data) 0)))
              (assoc-default 'description (elt (assoc-default 'textAnnotations data) 0)))))
      (with-temp-file (concat (file-name-sans-extension file) ".txt")
        (insert text))
      text)))

;;;###autoload
(defun sacha-image-rename-current-image-based-on-id (id)
  (interactive
   (let ((filename (if (derived-mode-p 'image-mode)
                       (buffer-file-name)
                     (dired-get-filename))))
     (list
      (if (string-match "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]" filename)
          (match-string 0 filename)
        (read-string "ID: ")))))
  (let* ((data (sacha-journal-get-by-zidstring id))
         (old-file (if (derived-mode-p 'image-mode)
                       (buffer-file-name)
                     (dired-get-filename)))
         (ext (file-name-extension old-file))
         (new-prefix (concat id " " (plist-get data :Note)))
         (text (plist-get data :Other))
         new-file)
    (when (and text (not (string= (string-trim text) "")))
      (with-temp-file (concat (file-name-sans-extension old-file) ".txt")
        (insert text)))
    (when (derived-mode-p 'image-mode)
      (kill-buffer))
    (setq new-file
          (sacha-image-store (sacha-rename-file-set old-file
                                              new-prefix t)
                          t))
    (when (derived-mode-p 'image-mode)
      (find-file new-file))
    (find-file (concat (file-name-sans-extension new-file) ".txt"))))

;;;###autoload
(defun sacha-image-recognize-get-new-filename (file)
  (interactive "FFile: ")
  (if-let* ((text (sacha-image-recognize file))
            (id (and (string-match "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9]" text)
                     (match-string 0 text)))
            (data (and id (sacha-journal-get-by-zidstring id))))
      (expand-file-name
       (concat id " " (plist-get data :Note) "." (file-name-extension file))
       (file-name-directory file))
    file))

;;;###autoload
(defun sacha-image-recognize-and-rename (file)
  (interactive "FFile: ")
  (let ((new-name (expand-file-name (sacha-image-recognize-get-new-filename file)
                                    (file-name-directory file))))
    (rename-file file new-name t)
    new-name))

;;;###autoload
(defun sacha-image-tags (file)
  (setq file (file-name-base file))
  (cond
   ((string-match "#\\([^ ]+\\)" file)
    (let ((start-pos 0))
      (cl-loop for match-pos = (string-match "#\\([^ \\.]+\\)" file start-pos)
               while match-pos
               collect (match-string 1 file)
               do (setf start-pos (1+ match-pos)))))
   ((string-match " -- \\(.+\\)" file)
    (split-string (match-string 1 file) " "))))

;;;###autoload
(defun sacha-image-name-without-tags (file)
  (replace-regexp-in-string " -- \\([^\\.]+\\)" (replace-regexp-in-string " #\\([^\\.]+\\)" "" file)))

;;;###autoload
(defun sacha-image-rename-set (old-name new-name &optional tags do-copy)
  (when (or (not (string= old-name new-name)) tags)
    (when tags
      (setq new-name (concat (sacha-image-name-without-tags new-name)
                             " -- "
                             (string-join tags " ")
                             (file-name-extension new-name))))
    (dolist (file (sacha-file-set old-name))
      (funcall
       (if do-copy
           'copy-file
         'rename-file)
       file
       (concat (file-name-sans-extension new-name) "." (file-name-extension file))
       t)))
  new-name)

;;;###autoload
(defun sacha-image-store (file &optional do-move)
  "Copy or move this image into public or private sketches as needed."
  (interactive (list (if (derived-mode-p 'image-mode)
                         (buffer-file-name)
                       (dired-get-filename))
                     t))
  (unless (string-match "^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9] " (file-name-nondirectory file))
    (setq file (sacha-image-recognize-and-rename file)))
  (if (string-match "^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-[0-9][0-9] " (file-name-nondirectory file))
      (let ((private (member "private" (sacha-image-tags file))))
        (sacha-image-rename-set
         file
         (expand-file-name
          (file-name-nondirectory file)
          (if private
              sacha-private-sketches-directory
            (car sacha-sketch-directories)))))
    file))

;;;###autoload
(defun sacha-image-copy-text (file)
  (interactive "FImage: ")
  (kill-new (sacha-image-recognize file)))

;;;###autoload
(defun sacha-image-insert-text-as-details (file)
  (interactive "FImage: ")
  (when (and (derived-mode-p 'org-mode)
             (eq (org-element-type (org-element-context)) 'link))
    (goto-char (org-element-end (org-element-context))))
  (insert "\n#+begin_my_details\n" (sacha-image-recognize file) "\n#+end_my_details\n"))

;;;###autoload
(defun sacha-image-thumbnail (path)
  (interactive "FImage: ")
  (let* ((filename (expand-file-name (concat "thumb-" (file-name-nondirectory path))
                                     (file-name-directory path))))
    (call-process "convert" nil nil nil path "-thumbnail" "500x" filename)
    (kill-new filename)
    filename))

;;;###autoload
(defun sacha-org-svg-copy-links (filename)
  (interactive (list (read-file-name "SVG: " nil
                                     nil
                                     (lambda (f)
                                       (or (string-match "\\.svg$" f)
                                           (file-directory-p f))))))
  (let ((dom (car (xml-parse-file filename))))
    (kill-new
     (mapconcat
      (lambda (elem)
        (concat "- " (org-link-make-string
                      (dom-attr elem 'href)
                      (or (dom-attr elem 'title)
                          (dom-text (dom-by-tag elem 'title))))))
      (dom-by-tag dom 'a)
      "\n"))))

(with-eval-after-load 'embark
  (defvar-keymap sacha-embark-image-actions
    :doc "Images"
    "k" #'sacha-image-open-in-krita
    "a" #'sacha-image-open-in-annotator
    "i" #'sacha-image-open-in-inkscape
    "w" #'sacha-image-copy-text
    "c" #'sacha-image-autocrop
    "]" #'sacha-image-rotate-clockwise
    "[" #'sacha-image-rotate-counterclockwise
    "g" #'sacha-image-open-in-gimp
    "f" #'sacha-open-in-firefox
    "s" #'sacha-image-store
    "r" #'sacha-image-recognize-and-rename
    "t" #'sacha-org-sketch-open-text-file
    "T" #'sacha-image-thumbnail
    "L" #'sacha-org-svg-copy-links
    "C" #'sacha-image-recolor
    "d" #'sacha-image-insert-text-as-details)
  (add-to-list 'embark-keymap-alist '(image . sacha-embark-image-actions)))

;;;###autoload
(defun sacha-subed-set-timestamp-to-mpv-position (&optional rest)
  (interactive)
  (skip-chars-backward "0-9:,.")
  (when (looking-at "\\(\\([0-9]+\\):\\)?\\([0-9]+\\):\\([0-9]+\\)\\.\\([0-9]+\\)")
    (replace-match (save-match-data (subed-msecs-to-timestamp subed-mpv-playback-position)) t t)))

;;;###autoload
(defun sacha-subed-adjust-timestamp (offset)
  (interactive (list -100))
  (save-excursion
    (skip-chars-backward "0-9:,.")
    (when (looking-at subed-vtt--regexp-timestamp)
      (let ((new-ts (+ (subed-vtt--timestamp-to-msecs (match-string 0)) offset)))
        (replace-match (save-match-data
                         (subed-vtt--msecs-to-timestamp new-ts)))
        (sacha-waveform-subed-show-after-time)
        new-ts))))

;;;###autoload
(defun sacha-subed-adjust-timestamp-up (offset)
  (interactive (list 100))
  (subed-mpv-jump (sacha-subed-adjust-timestamp (- offset))))

;;;###autoload
(defun sacha-subed-adjust-timestamp-down (offset)
  (interactive (list -100))
  (subed-mpv-jump (sacha-subed-adjust-timestamp (- offset))))

;;;###autoload
(defun sacha-subed-copy-timestamp-from-previous ()
  (interactive)
  (let ((ms (save-excursion (subed-backward-subtitle-time-stop) (subed-subtitle-msecs-stop))))
    (subed-set-subtitle-time-start ms)))
;;;###autoload
(defun sacha-subed-copy-timestamp-to-next ()
  (interactive)
  (let ((ms (subed-subtitle-msecs-stop)))
    (save-excursion
      (subed-forward-subtitle-time-stop) (subed-set-subtitle-time-start ms))))
;;;###autoload
(defun sacha-subed-copy-timestamp-dwim ()
  (interactive)
  (save-excursion
    (skip-chars-backward "0-9:,.")
    (if (bolp)
        (sacha-subed-copy-timestamp-from-previous)
      (sacha-subed-copy-timestamp-to-next))))

;;;###autoload
(defun sacha-embark-subed-timestamp ()
  (save-excursion
    (skip-chars-backward "0-9:,.")
    (when (looking-at "\\(\\([0-9]+\\):\\)?\\([0-9]+\\):\\([0-9]+\\)\\.\\([0-9]+\\)")
      (list 'subed-timestamp
            (propertize
             (match-string 0)
             'ms (compile-media-timestamp-to-msecs (match-string 0))
             'position (if (bolp) 'start 'stop))))))

(defhydra sacha-subed-adjust-timestamp ()
  ("<up>" sacha-subed-adjust-timestamp-up "Up" :exit nil)
  ("<down>" sacha-subed-adjust-timestamp-down "Down" :exit nil))

  (use-package casual-symbol-overlay
          :if sacha-laptop-p
          :after embark
          :init
          (with-eval-after-load 'embark
                  (keymap-set embark-symbol-map "z" #'casual-symbol-overlay-tmenu)))

;;;###autoload
(defun sacha-embark-erefactor-rename-symbol-in-buffer (old-name new-name)
  (interactive (let* ((old-name (read-string "Symbol: "))
                      (new-name (read-string (format "%s -> New name: " old-name)
                                             old-name
                                             'erefactor--read-symbol-history)))
                 (list old-name new-name)))
  (erefactor-rename-symbol-in-buffer old-name new-name))

(with-eval-after-load 'embark
  (keymap-set embark-command-map "r" #'sacha-embark-erefactor-rename-symbol-in-buffer)
  (keymap-set embark-symbol-map "r" #'sacha-embark-erefactor-rename-symbol-in-buffer))

(defun sacha-hydra-format-head (h)
  (let ((key-binding (elt h 0))
        (hint (elt h 2))
        (cmd (and (elt h 1) (prin1-to-string (elt h 1)))))
    (if cmd
        (format "%s (%s) - %s" hint key-binding cmd)
      (format "%s (%s)" hint key-binding))))

(defun sacha-hydra-heads-to-candidates (base)
  (mapcar (lambda (h)
            (cons (sacha-hydra-format-head h) (hydra--head-name h base)))
          (symbol-value (intern (concat (symbol-name base) "/heads")))))

;;;###autoload
(defun sacha-hydra-execute-extended (&optional _ hydra-base)
  (interactive (list current-prefix-arg nil))
  (hydra-keyboard-quit)
  (let* ((candidates (sacha-hydra-heads-to-candidates
                      (or hydra-base
                          (intern
                           (replace-regexp-in-string "/body$" ""
                                                     (symbol-name hydra-curr-body-fn))))))
         (command-name (completing-read "Cmd: " candidates))
         (bind (assoc-default command-name candidates 'string=)))
    (cond
     ((null bind) nil)
     ((hydra--callablep bind) (call-interactively bind)))))

     (with-eval-after-load 'hydra
       (define-key hydra-base-map (kbd "<tab>") #'sacha-hydra-execute-extended))

(defalias 'sacha-complete-blog-post-url #'sacha-org-blog-complete)

;;;###autoload
(defun sacha-blog-posts (&optional start end filter-fn)
  (let ((json-object-type 'alist)
        (data (json-read-file "~/proj/static-blog/_site/blog/all/index.json")))
    (if (or start end)
        (seq-filter
         (lambda (o)
           (and (or (null start) (not (string< (alist-get 'date o) start)))
                (or (null end) (string< (alist-get 'date o) end))
                (or (null filter-fn) (funcall filter-fn o))))
         data)
      data)))

;;;###autoload
(defun sacha-blog-edit-html (url)
  (interactive (list (sacha-org-blog-complete)))
  (let ((base (replace-regexp-in-string
               (concat "^" (regexp-quote sacha-blog-base-url))
               ""
               url))
        (filename (sacha-11ty-html-filename url)))
    (if filename
        (find-file filename)
      (error "Could not find file."))))

;;;###autoload
(defun sacha-blog-edit-json (url)
  (interactive (list (sacha-org-blog-complete)))
  (let* ((filename (sacha-11ty-html-filename url))
         (json (and filename (concat (file-name-sans-extension filename) ".11tydata.json"))))
    (if json
        (find-file json)
      (error "Could not find file."))))

;;;###autoload
(defun sacha-view-blog-post-locally (url)
  (interactive (list (sacha-org-blog-complete)))
  (browse-url
   (replace-regexp-in-string
    (concat "^" (regexp-quote sacha-blog-base-url))
    "https://localhost:8080/"
    url)))

;;;###autoload
(defun sacha-insert-blog-post-url (url)
  (interactive (list (sacha-complete-blog-post-url)))
  (insert url))

;;;###autoload
(defun sacha-blog-title (url)
  (let ((base (replace-regexp-in-string
               (concat "^" (regexp-quote sacha-blog-base-url))
               "/"
               url)))
    (alist-get 'title
               (seq-find (lambda (o)
                           (string= (alist-get 'permalink o) base))
                         (sacha-blog-posts)))))

;;;###autoload
(defun sacha-insert-blog-post-link (url)
  (interactive (list (sacha-complete-blog-post-url)))
  (if (derived-mode-p 'org-mode)
      (insert (org-link-make-string
               url
               (sacha-blog-title url)))
    (insert url)))

(declare-function 'sacha-geeqie-view "Sacha.el")

(defvar sacha-sketch-preview 'text
  "*Preview sketches.
  'text means show the associated text.
  'geeqie means open image in Geeqie.
  t means open image in Emacs.")

(defun sacha-image--state ()
  "Manage preview window and cleanup."
  ;; These functions are closures captured when the state is initialized by consult--read
  (let ((preview (consult--buffer-preview))
        (open (consult--temporary-files)))
    ;; The returned lambda is the actual preview function called by Consult
    (lambda (action cand)
      (unless cand
        (funcall open))
      (when sacha-sketch-preview
        (let ((filename (cond
                         ((and (eq sacha-sketch-preview 'text)
                               (listp cand)
                               (alist-get 'source_path cand))
                          (alist-get 'source_path cand))
                         ((and (listp cand)
                               (alist-get 'source_path cand))
                          (sacha-image-filename (file-name-base (alist-get 'source_path cand))))
                         (t cand))))
          (when filename
            (pcase sacha-sketch-preview
              ('geeqie (sacha-geeqie-view (list filename)))
              (_ (funcall preview action
                          (and cand
                               (eq action 'preview)
                               (funcall open filename)))))))))))

;;;###autoload
(defun sacha-complete-sketch-filename (&optional filter)
  (interactive)
  (consult--read (sacha-sketches filter)
                 :sort nil
                 :state (sacha-image--state)
                 :prompt "Sketch: "
                 :category 'sketch))

(defun sacha-date-from-filename (filename)
  (let ((f (file-name-nondirectory filename)))
    (if (string-match "^[-0-9]+" f)
        (replace-regexp-in-string "[^0-9]" "" (match-string 0 f))
      nil)))

(defvar sacha-sketches nil "Cache for sketch filenames.")

;;;###autoload
(defun sacha-sketches (&optional filter)
  (interactive)
  (let (results)
    (setq results
          (apply 'append (mapcar (lambda (dir)
                                   (directory-files dir t "\\.\\(jpe?g\\|png\\|svg\\)$"))
                                 sacha-sketch-directories)))
    (when filter
      (setq results (seq-filter (lambda (o) (string-match filter o))
                                results)))
    (sort
     results
     (lambda (a b)
       (string< (concat (or (sacha-date-from-filename b) "0") (file-name-nondirectory b))
                (concat (or (sacha-date-from-filename a) "0") (file-name-nondirectory a)))))))

;;;###autoload
(defun sacha-find-sketch (file)
  (interactive (list (sacha-complete-sketch-filename)))
  (find-file file))

;;;###autoload
(defun sacha-sketch-prepare-post (file)
  (interactive (list (sacha-complete-sketch-filename)))
  (insert (org-link-make-string (concat "sketchFull:" (file-name-base file))))
  (let ((text (sacha-sketch-text file)))
    (when text
      (insert (format "\n\n#+begin_my_src \"Text from %s\"\n%s\n#")))))

(defun sacha-sketch-text (file)
  (cond
   ((file-exists-p (concat (file-name-sans-extension file) ".txt"))
    (with-temp-buffer
      (insert-file-contents (concat (file-name-sans-extension file) ".txt"))
      (buffer-string)))
   ((file-exists-p (concat (file-name-sans-extension file) ".json"))
    (let ((json-object-type 'alist))
      (assoc-default 'description (elt (assoc-default 'textAnnotations (json-read-file (concat (file-name-sans-extension file) ".json"))) 0))))
   (t (error "Can't find text."))))

;;;###autoload
(defun sacha-sketch-insert-text (file)
  (interactive "FFile: ")
  (let ((text (sacha-sketch-text file)))
    (insert (or text ""))))

       (use-package consult-dir
              :ensure t
              :bind (("C-x C-d" . consult-dir)
                     :map minibuffer-local-completion-map
                     ("C-x C-d" . consult-dir)
                     ("C-x C-j" . consult-dir-jump-file)))

;; https://karthinks.com/software/jumping-directories-in-eshell/
;;;###autoload
(defun eshell/z (&optional regexp)
  "Navigate to a previously visited directory in eshell, or to
       any directory proferred by `consult-dir'."
  (let ((eshell-dirs (delete-dups
                      (mapcar 'abbreviate-file-name
                              (ring-elements eshell-last-dir-ring)))))
    (cond
     ((and (not regexp) (featurep 'consult-dir))
      (let* ((consult-dir--source-eshell `(:name "Eshell"
                                                 :narrow ?e
                                                 :category file
                                                 :face consult-file
                                                 :items ,eshell-dirs))
             (consult-dir-sources (cons consult-dir--source-eshell
                                        consult-dir-sources)))
        (eshell/cd (substring-no-properties
                    (consult-dir--pick "Switch directory: ")))))
     (t (eshell/cd (if regexp (eshell-find-previous-directory regexp)
                     (completing-read "cd: " eshell-dirs)))))))

  (use-package consult
    :after projectile
    :defines consult-buffer-sources
    :config
    (projectile-load-known-projects)
    (setq sacha-consult-source-projectile-projects
          `(:name "Projectile projects"
                  :narrow   ?P
                  :category project
                  :action   ,#'projectile-switch-project-by-name
                  :items    ,projectile-known-projects))
    (add-to-list 'consult-buffer-sources 'sacha-consult-source-projectile-projects 'append))

  (defun sacha-insert-or-replace-link (url &optional title)
          "Insert a link, wrap the current region in a link, or replace the current link."
          (interactive (list (read-string "URL: ")))
          (cond
           ((derived-mode-p 'org-mode)
                  (cond
                   ((org-in-regexp org-link-bracket-re 1)
                          (when (match-end 2) (setq title (match-string-no-properties 2)))
                          (delete-region (match-beginning 0) (match-end 0)))
                   ((org-in-regexp org-link-any-re 1)
                          (delete-region (match-beginning 0) (match-end 0)))
                   ((region-active-p)
                          (setq title (buffer-substring-no-properties (region-beginning) (region-end)))
                          (delete-region (region-beginning) (region-end))))
                  ;; update link
                  (insert (org-link-make-string url title)))
           ((derived-mode-p 'org-mode)     ; not in a link
                  (insert (org-link-make-string url title)))
           ((and (region-active-p) (derived-mode-p 'markdown-mode))
                  (setq title (buffer-substring-no-properties (region-beginning) (region-end)))
                  (delete-region (region-beginning) (region-end))
                  (insert (format "[%s](%s)" title url)))
           ((derived-mode-p 'markdown-mode)
                  (insert (format "[%s](%s)" title url)))
           ((and (region-active-p) (string-match (regexp-quote "*new toot*") (buffer-name)))
                  (setq title (buffer-substring-no-properties (region-beginning) (region-end)))
                  (delete-region (region-beginning) (region-end))
                  (insert (format "[%s](%s)" title url)))
           ((string-match (regexp-quote "*new toot*") (buffer-name))
                  (insert (format "[%s](%s)" (read-string "Title: " (sacha-page-title url))
                                                                                  url)))
           (t
                  (insert (format "%s (%s)" title url)))))

  ;; override the embark actions
  (defun sacha-consult-omni-embark-copy-url-as-kill (cand)
          "Don't add spaces."
          (when-let ((s (and (stringp cand) (get-text-property 0 :url cand))))
                  (kill-new (string-trim s))))

  (defun sacha-consult-omni-embark-insert-url (cand)
          "Don't add spaces."
          (when-let ((s (and (stringp cand) (get-text-property 0 :url cand))))
                  (insert (string-trim s))))

  (defun sacha-consult-omni-embark-copy-title-as-kill (cand)
          "Don't add spaces."
          (when-let ((s (and (stringp cand) (get-text-property 0 :title cand))))
                  (kill-new (string-trim s))))

  (defun sacha-consult-omni-embark-insert-title (cand)
          "Don't add spaces."
          (when-let ((s (and (stringp cand) (get-text-property 0 :title cand))))
                  (insert (string-trim s))))

  (defun sacha-consult-omni-embark-insert-link (cand)
          "Don't add spaces."
          (let ((url (and (stringp cand) (get-text-property 0 :url cand)))
                                  (title (and (stringp cand) (get-text-property 0 :title cand))))
                  (sacha-insert-or-replace-link url title)))

  (use-package consult-omni
          :defer t
          :commands consult-omni
          :load-path "~/vendor/consult-omni"
    :after (consult embark)
    :custom
    (consult-omni-show-preview t) ;;; show previews
    (consult-omni-preview-key "C-o") ;;; set the preview key to C-o
    :config
          (add-to-list 'load-path "~/vendor/consult-omni/sources")
    (require 'consult-omni-sources)
    (require 'consult-omni-embark)
    (setq consult-omni-sources-modules-to-load (list 'consult-omni-wikipedia 'consult-omni-google))
    (consult-omni-sources-load-modules)
          (setq consult-omni-dynamic-input-debounce 1.0)
          (setq consult-omni-dynamic-refresh-delay consult-omni-dynamic-input-debounce)
    (setq consult-omni-default-interactive-command #'consult-omni-multi)
          (setq consult-omni-multi-sources
                                  '(consult-omni--source-google
                                          consult-omni--source-sacha-org-bookmarks
                                          consult-omni--source-blog))
          :bind
          (("M-g w" . consult-omni)
           ("M-g f" . consult-omni-sacha-org-bookmarks)
           :map consult-omni-embark-general-actions-map
           ("i l" .  #'sacha-consult-omni-embark-insert-link)
           ("i u" .  #'sacha-consult-omni-embark-insert-url)
           ("i t" .  #'sacha-consult-omni-embark-insert-title)
           ("w u" . #'sacha-consult-omni-embark-copy-url-as-kill)
           ("w t" . #'sacha-consult-omni-embark-copy-title-as-kill)))

;;;###autoload
  (defun sacha-search-notes ()
          (interactive)
          (consult-ripgrep '("~/sync/orgzly" "~/sync/static-blog/blog" "~/sync/sketches" "~/sync/topics")))
;;;###autoload
  (defun sacha-search-public-notes ()
          (interactive)
          (consult-ripgrep '("~/sync/static-blog/blog" "~/sync/sketches" "~/sync/topics")))

;;;###autoload
  (cl-defun sacha-consult-omni--google-blog-fetch-results (input &rest args &key callback &allow-other-keys)
    "Fetches search results for INPUT from “Google Custom Search” service.
  Narrows to `sacha-blog-base-url'.

  Refer to URL `https://programmablesearchengine.google.com/about/' and
  URL `https://developers.google.com/custom-search/' for more info."
    (pcase-let* ((`(,query . ,opts)
                  (consult-omni--split-command input (seq-difference args (list :callback callback))))
                 (opts (car-safe opts))
                 (count (plist-get opts :count))
                 (page (plist-get opts :page))
                 (filter (plist-get opts :filter))
                 (count (or (and count (integerp (read count)) (string-to-number count))
                            consult-omni-default-count))
                 (page (or (and page (integerp (read page)) (string-to-number page))
                           consult-omni-default-page))
                 (filter (or (and (integerp filter) filter)
                             (and filter (string-to-number (format "%s" filter)))
                             1))
                 (filter (if (member filter '(0 1)) filter 1))
                 (count (min count 10))
                 (page (+ (* page count) 1))
                 (page (min page (- 100 count)))
                 (params `(("q" . ,(format "site:%s+%s"
                                           (url-encode-url sacha-blog-base-url)
                                           (replace-regexp-in-string " " "+" query)))
                           ("key" . ,(consult-omni-expand-variable-function consult-omni-google-customsearch-key))
                           ("cx" . ,(consult-omni-expand-variable-function consult-omni-google-customsearch-cx))
                           ("gl" . "en")
                           ("filter" . ,(format "%s" filter))
                           ("num" . ,(format "%s" count))
                           ("start" . ,(format "%s" page))))
                 (headers '(("Accept" . "application/json")
                            ("Accept-Encoding" . "gzip")
                            ("User-Agent" . "consult-omni (gzip)"))))
      (consult-omni--fetch-url
       consult-omni-google-customsearch-api-url consult-omni-http-retrieve-backend
       :encoding 'utf-8
       :params params
       :headers headers
       :parser #'consult-omni--json-parse-buffer
       :callback
       (lambda (attrs)
         (let* ((raw-results (gethash "items" attrs))
                (annotated-results
                 (mapcar (lambda (item)
                           (let*
                               ((source "Google")
                                (url (format "%s" (gethash "link" item)))
                                (title (format "%s" (gethash "title" item)))
                                (snippet (string-trim (format "%s" (gethash "snippet" item))))
                                (search-url (consult-omni--make-url-string consult-omni-google-search-url params '("key" "cx" "gl")))
                                (decorated (funcall consult-omni-default-format-candidate :source source :query query :url url :search-url search-url :title title :snippet snippet)))
                             (propertize decorated
                                         :source source
                                         :title title
                                         :url url
                                         :search-url search-url
                                         :query query
                                         :snippet snippet)))
                         raw-results)))
           (when (and annotated-results (functionp callback))
             (funcall callback annotated-results))
           annotated-results)))))

  (use-package consult-omni
          :load-path "~/vendor/consult-omni"
          :after (consult embark)
          :config
    (consult-omni-define-source
     "Google my blog"
     :narrow-char ?b
     :type 'dynamic
     :require-match nil
     :face 'consult-omni-engine-title-face
     :request #'sacha-consult-omni--google-blog-fetch-results
     :on-new (apply-partially #'consult-omni-external-search-with-engine "Google")
     :preview-key consult-omni-preview-key
     :search-hist 'consult-omni--search-history
     :select-hist 'consult-omni--selection-history
     :enabled (lambda () (bound-and-true-p consult-omni-google-customsearch-key))
     :group #'consult-omni--group-function
     :sort t
     :interactive consult-omni-intereactive-commands-type
     :annotate nil))

  (keymap-global-set "M-g b" #'sacha-search-public-notes)
  (keymap-global-set "M-g N" #'sacha-search-notes)
  (keymap-global-set "M-g B" #'consult-omni-google-sacha-blog)

;;;###autoload
  (defun sacha-marginalia-annotate-journal (cand)
    (when-let ((o (cdr (assoc cand sacha-journal-search-cache))))
      (marginalia--fields
       ((plist-get o :Category)
        :face 'marginalia-documentation
        :truncate 13))))

  (use-package marginalia
    :config
    (add-to-list 'marginalia-annotators '(journal sacha-marginalia-annotate-journal builtin none)))

;;;###autoload
  (defun sacha-setup-color-theme ()
    (interactive)
    (when (display-graphic-p)
      (load-theme (car modus-themes-to-toggle) t)))

  (use-package modus-themes
          :vc (:url "https://github.com/protesilaos/modus-themes")
          :init (setq modus-themes-to-toggle '(modus-operandi-tinted modus-vivendi-tinted))
          :config (sacha-setup-color-theme))

(defun sacha-hl-sexp-update-overlay ()
  (when (overlayp hl-sexp-overlay)
    (overlay-put
     hl-sexp-overlay
     'face
     `(:background
       ,(modus-themes-get-color-value 'bg-inactive)))))
(defun sacha-hl-sexp-update-all-overlays (&rest args)
  (dolist (buf (buffer-list))
    (with-current-buffer buf
      (when highlight-sexp-mode
        (sacha-hl-sexp-update-overlay)))))

  (use-package highlight-sexp
    :vc (:url "https://github.com/daimrod/highlight-sexp")
    :after modus-themes
    :hook
    ((emacs-lisp-mode . highlight-sexp-mode)
           (modus-themes-after-load-theme . sacha-hl-sexp-update-all-overlays))
          :config
          (advice-add 'hl-sexp-create-overlay :after 'sacha-hl-sexp-update-overlay))

  (display-time-mode 1)

  (use-package diminish :ensure t)

;;;###autoload
  (defun sacha-update-active-mode-line-colors ()
          (set-face-attribute
           'mode-line nil
           :foreground (modus-themes-get-color-value 'fg-mode-line-active)
           :background (modus-themes-get-color-value 'bg-blue-subtle)))

  (use-package modus-themes
          :hook
          (modus-themes-after-load-theme . sacha-update-active-mode-line-colors))

;;;###autoload
  (defun sacha-pdf-view-insert-current-page-text ()
          (interactive)
          (let (text)
                  (catch 'found
                          (walk-window-tree
                           (lambda (win)
                                   (with-selected-window win
                                           (when (derived-mode-p 'pdf-view-mode)
                                                   (setq text
                                                                           (pdf-info-gettext (pdf-view-current-page)
                                                                                                                                                   (list 0 0 1 1)))
                                                   (throw 'found text))))))
                  (when text (save-excursion (insert text)))))

;;;###autoload
  (defun sacha-replace-with-latest-download ()
    "Replace file contents with latest download."
    (interactive)
    (widen)
    (erase-buffer)
    (insert-file-contents (sacha-latest-file sacha-download-dir)))

;;;###autoload
  (defun zap-to-isearch (rbeg rend)
    "Kill the region between the mark and the closest portion of
        the isearch match string. The behaviour is meant to be analogous
        to zap-to-char; let's call it zap-to-isearch. The deleted region
        does not include the isearch word. This is meant to be bound only
        in isearch mode.  The point of this function is that oftentimes
        you want to delete some portion of text, one end of which happens
        to be an active isearch word. The observation to make is that if
        you use isearch a lot to move the cursor around (as you should,
        it is much more efficient than using the arrows), it happens a
        lot that you could just delete the active region between the mark
        and the point, not include the isearch word."
    (interactive "r")
    (when (not mark-active)
      (error "Mark is not active"))
    (let* ((isearch-bounds (list isearch-other-end (point)))
           (ismin (apply 'min isearch-bounds))
           (ismax (apply 'max isearch-bounds))
           )
      (if (< (mark) ismin)
          (kill-region (mark) ismin)
        (if (> (mark) ismax)
            (kill-region ismax (mark))
          (error "Internal error in isearch kill function.")))
      (isearch-exit)
      ))

  (define-key isearch-mode-map [(meta z)] 'zap-to-isearch)

  (require 'transient)
  (transient-define-prefix cc/isearch-menu ()
    "isearch Menu"
    [["Edit Search String"
      ("e"
       "Edit the search string (recursive)"
       isearch-edit-string
       :transient nil)
      ("w"
       "Pull next word or character word from buffer"
       isearch-yank-word-or-char
       :transient nil)
      ("s"
       "Pull next symbol or character from buffer"
       isearch-yank-symbol-or-char
       :transient nil)
      ("l"
       "Pull rest of line from buffer"
       isearch-yank-line
       :transient nil)
      ("y"
       "Pull string from kill ring"
       isearch-yank-kill
       :transient nil)
      ("t"
       "Pull thing from buffer"
       isearch-forward-thing-at-point
       :transient nil)]

     ["Replace"
      ("q"
       "Start ‘query-replace’"
       isearch-query-replace
       :if-nil buffer-read-only
       :transient nil)
      ("x"
       "Start ‘query-replace-regexp’"
       isearch-query-replace-regexp
       :if-nil buffer-read-only
       :transient nil)]]

    [["Toggle"
      ("X"
       "Regexp searching"
       isearch-toggle-regexp
       :transient nil)
      ("S"
       "Symbol searching"
       isearch-toggle-symbol
       :transient nil)
      ("W"
       "Word searching"
       isearch-toggle-word
       :transient nil)
      ("F"
       "Case fold"
       isearch-toggle-case-fold
       :transient nil)
      ("L"
       "Lax whitespace"
       isearch-toggle-lax-whitespace
       :transient nil)]

     ["Misc"
      ("o"
       "occur"
       isearch-occur
       :transient nil)
      ("h"
       "highlight"
       isearch-highlight-regexp
       :transient nil)
      ("H"
       "highlight lines"
       isearch-highlight-lines-matching-regexp
       :transient nil)]])

  (define-key isearch-mode-map (kbd "M-S") 'cc/isearch-menu)

  (setq isearch-invisible t
                          search-invisible t)

  (with-eval-after-load 'occur
          (keymap-set occur-mode-map "C-x C-q" #'occur-edit-mode))

  (defvar sacha-screenshot-dirs
          '("~/recordings"
                  "~/.var/app/org.prismlauncher.PrismLauncher/data/PrismLauncher/instances/"
                  "~/sync/gdlauncher-instances/"
                  ))
  (defvar sacha-recent-screenshot-limit 50)

;;;###autoload
  (defun sacha-combined-screenshots (&optional limit)
          (seq-take
           (sort
                  (seq-mapcat (lambda (dir)
                                                                          (directory-files-recursively dir "[0-9][0-9][0-9][0-9]-.*\\.\\(png\\|webm\\|gif\\|svg\\|mkv\\)"))
                                                                  sacha-screenshot-dirs)
                  :key (lambda (o) (file-attribute-modification-time (file-attributes o)))
                  :reverse t)
           (or limit sacha-recent-screenshot-limit)))

;;;###autoload
  (defun sacha-latest-screenshot ()
          (car (sacha-combined-screenshots)))

;;;###autoload
  (defun sacha-show-combined-screenshots (&optional limit)
          "Show thumbnails for combined screenshots."
          (interactive (list (when current-prefix-arg (read-number "Limit: "))))
          (condition-case nil
                          ;; ignore errors from image-dired trying to set default-directory
                          (image-dired-show-all-from-dir
                           (cons (car sacha-screenshot-dirs) (sacha-combined-screenshots limit)))
                  (error nil)))

;;;###autoload
(defun sacha-org-image-dired-store-link ()
  (when (and (derived-mode-p 'image-dired-thumbnail-mode)
             (get-text-property (point) 'original-file-name))
    (org-link-store-props
     :link (concat "file:" (get-text-property (point) 'original-file-name)))))

(with-eval-after-load 'org
  (org-link-set-parameters
   "image-dired"
   :store #'sacha-org-image-dired-store-link))

;;;###autoload
(defun sacha-org-yank-file-links-from-kill-ring ()
  (interactive)
  (dolist (file (read (concat "(" (current-kill 0) ")")))
    (insert (org-link-make-string (concat "file:" file)) "\n")))

(use-package peep-dired
  :if sacha-laptop-p
  :bind (:map peep-dired-mode-map
              ("SPC" . nil)
              ("<backspace>" . nil)))

;;;###autoload
(defun sacha-save-photo (name)
  (interactive "MName: ")
  (let* ((file (dired-get-filename))
         new-name)
    (cond
     ((string-match "CameraZOOM-\\([0-9][0-9][0-9][0-9]\\)\\([0-9][0-9]\\)\\([0-9][0-9]\\)\\([0-9][0-9]\\)\\([0-9][0-9]\\)\\([0-9][0-9]\\)\\([0-9][0-9][0-9]\\)" file)
      (setq new-name
            (format "%s-%s-%s %s.%s.%s.%s %s.jpg"
                    (match-string 1 file)
                    (match-string 2 file)
                    (match-string 3 file)
                    (match-string 4 file)
                    (match-string 5 file)
                    (match-string 6 file)
                    (match-string 7 file)
                    name)))
     ((string-match "\\([0-9][0-9][0-9][0-9]\\)[\\.-]\\([0-9][0-9]\\)[\\.-]\\([0-9][0-9]\\)[\\.- ]\\([0-9][0-9]\\)\\.\\([0-9][0-9]\\)\\.\\([0-9][0-9]\\)" file)
      (setq new-name
            (format "%s-%s-%s %s.%s.%s %s.jpg"
                    (match-string 1 file)
                    (match-string 2 file)
                    (match-string 3 file)
                    (match-string 4 file)
                    (match-string 5 file)
                    (match-string 6 file)
                    name)))
     (t (setq new-name (concat (file-name-sans-extension (file-name-nondirectory file)) " " name ".jpg"))))
    (when (string-match "A-" name)
      (copy-file file (expand-file-name new-name sacha-kid-photo-directory)))
    (rename-file file (expand-file-name new-name "~/archives/2016/photos/selected/"))))
;;;###autoload
(defun sacha-backup-media ()
  (interactive)
  (mapcar (lambda (file)
            (rename-file
             file
             (expand-file-name
              (file-name-nondirectory file)
              (cond
               ((string-match "mp4" file) "~/archives/2016/videos/")
               ((string-match "mp3\\|wav" file) "~/archives/2016/audio/")
               (t "~/archives/2016/photos/backup/")))))
          (dired-get-marked-files)))

(bind-key "b" 'sacha-save-photo dired-mode-map)
(bind-key "r" 'sacha-backup-media dired-mode-map)

;;;###autoload
(defun sacha-describe-random-interactive-function ()
  (interactive)
  "Show the documentation for a random interactive function.
       Consider only documented, non-obsolete functions."
  (let (result)
    (mapatoms
     (lambda (s)
       (when (and (commandp s)
                  (documentation s t)
                  (null (get s 'byte-obsolete-info)))
         (setq result (cons s result)))))
    (describe-function (elt result (random (length result))))))

;;;###autoload
(defun sacha-shuffle-lines-in-region (beg end)
  "Randomize the order of lines from BEG to END."
  (interactive "r")
  (let ((list (split-string (buffer-substring beg end) "[\r\n]+")))
    (delete-region beg end)
    (insert (string-join (seq-sort-by (lambda (_) (random)) #'<= list) "\n"))))

  (defvar sacha-learn-lang-practice-dir "~/proj/french/audio")
  (defvar sacha-learn-lang-practice-temp (expand-file-name "temp.wav" sacha-learn-lang-practice-dir))
;;;###autoload
  (defun sacha-learn-lang-practice-line ()
    (interactive)
    (sit-for 1)
    (let* ((date (format-time-string "%Y-%m-%d-%H-%M-%S"))
           (filename
            (expand-file-name
             (concat date " "
                     (string-trim
                      (buffer-substring (line-beginning-position)
                                        (line-end-position)))
                     ".opus")
             sacha-learn-lang-practice-dir))
           (process (start-process "arecord"
                                   (get-buffer-create "*record*")
                                   "arecord" "-D" "hw:2,0" "-t" "wav" "-f" "cd"
                                   sacha-learn-lang-practice-temp)))
      (read-key "Press a key")
      (kill-process process)
      (call-process "ffmpeg" nil (get-buffer-create "*record*") nil
                    "-y"
                    "-i"
                    sacha-learn-lang-practice-temp
                    "-af" "silenceremove=start_periods=1:start_duration=0:start_threshold=-60dB,areverse,silenceremove=start_periods=1:start_duration=0:start_threshold=-60dB,areverse,loudnorm=I=-16:LRA=11:TP=-1.5"
                    filename)
      (mpv-play filename)))

;;;###autoload
  (defun sacha-learn-lang-practice-replay ()
    (interactive)
    (mpv-play (sacha-latest-file sacha-learn-lang-practice-dir)))

;;;###autoload
  (defun sacha-learn-lang-practice-transcribe ()
    (interactive)
    (let* ((default-directory sacha-learn-lang-practice-dir)
           (file (sacha-latest-file sacha-learn-lang-practice-dir "\\.opus\\|\\.m4a\\|\\.webm")))
      ;; (call-process "/bin/bash" nil nil nil "/home/sacha/bin/whisperx" (expand-file-name file))
      (message "%s"
               (with-temp-buffer
                 (insert-file-contents (concat (file-name-sans-extension file) ".txt"))
                 (string-trim (buffer-string))))))

;;;###autoload
  (defun sacha-learn-lang-practice-play-current-reference (&optional beg end)
    "Play the current segment."
    (interactive)
    (when (derived-mode-p 'subed-mode)
      (let ((comment (subed-subtitle-comment)))
        (cond
         ((string-match "#\\+REFERENCE: \\(.+\\) +\\(.+?\\) +--> +\\([^ ]+\\)" comment)
          (let ((file (expand-file-name (match-string 1 comment)))
                (start (match-string 2 comment))
                (stop (match-string 3 comment)))
            (call-process "mpv" nil nil nil
                          file
                          (format "--start=%.3f" (/ (subed-timestamp-to-msecs start) 1000.0))
                          (format "--end=%.3f" (/ (subed-timestamp-to-msecs stop) 1000.0)))))
         ((string-match "#\\+REFERENCE: \\(.+\\)" comment)
          (call-process "mpv" nil nil nil (match-string 1 comment)))
        (t (let ((start
                 (if beg (save-excursion
                           (goto-char beg)
                           (subed-subtitle-msecs-start))
                   (subed-subtitle-msecs-start)))
                (stop
                 (if beg (save-excursion
                           (goto-char end)
                           (subed-subtitle-msecs-stop))
                   (subed-subtitle-msecs-stop))))
            (call-process "mpv" nil nil nil (subed-media-file)
                          (format "--start=%.3f" (/ start 1000.0))
                          (format "--end=%.3f" (/ stop 1000.0)))))))))

;;;###autoload
  (defun sacha-learn-lang-practice-record-loop (&optional extra)
    (interactive
     (list (cond
            ((and (derived-mode-p 'subed-mode)
                  (region-active-p))
             (subed-subtitle-list-text
              (subed-subtitle-list
               (region-beginning)
               (region-end))))
            ((region-active-p)
             (concat
              " "
              (string-trim
               (buffer-substring (region-beginning) (region-end)))))
            ((derived-mode-p 'subed-mode)
             (concat " " (subed-subtitle-text))))))
    (let* ((date (format-time-string "%Y-%m-%d-%H-%M-%S"))
           (key-prompt "%d (SPC to review, RET get feedback, q to quit, any other key to retry")
           (filename
            (expand-file-name
             (concat date
                     (if extra
                         (concat " "
                                 (string-trim (replace-regexp-in-string
                                               "[\\?]+" " "
                                               (car
                                                (split-string
                                                 extra "\n")))))
                       "")

                     ".opus")
             sacha-learn-lang-practice-dir))
           done
           char
           (count 0)
           process)
      (while (not done)
        (when (derived-mode-p 'subed-mode)
          (if (region-active-p)
              (sacha-learn-lang-practice-play-current-reference (region-beginning) (region-end))
            (sacha-learn-lang-practice-play-current-reference)))
        (setq count (1+ count))
        (setq process (start-process "ffmpeg"
                                     (get-buffer-create "*record*")
                                     "ffmpeg" "-y" "-f" "pulse" "-i" "alsa_input.usb-Blue_Microphones_Yeti_Stereo_Microphone_REV8-00.analog-stereo"
                                     sacha-learn-lang-practice-temp))
        (setq char
              (read-key (format key-prompt
                                count)))
        (while char
          (pcase char
            (?\  (when (process-live-p process)
                   (sit-for 1)
                   (kill-process process))
                 (sacha-learn-lang-practice-play-current-reference)
                 (call-process "mpv" nil nil nil sacha-learn-lang-practice-temp)
                 (setq char
                       (read-key (format "%d (SPC to review, RET get feedback, q to quit, any other key to retry"
                                         count))))
            (13 (when (process-live-p process)
                  (sit-for 1)
                  (kill-process process))
                (setq done 'feedback)
                (setq char nil))
            (?w            ; transcribe with Whisper
             (sacha-learn-lang-practice-transcribe))
            (?q
             (when (process-live-p process) (kill-process process))
             (setq done 'ignore)
             (setq char nil))
            (_
             (when (process-live-p process) (kill-process process))
             (setq char nil)))))
        (when (member done '(keep feedback))
          (call-process "ffmpeg" nil (get-buffer-create "*record*") nil
                        "-y"
                        "-i"
                        sacha-learn-lang-practice-temp
                        "-af" "loudnorm=I=-16:LRA=11:TP=-1.5"
                        ;; "-af" "silenceremove=start_periods=1:start_duration=0:start_threshold=-100dB,areverse,silenceremove=start_periods=1:start_duration=0:start_threshold=-100dB,areverse,loudnorm=I=-16:LRA=11:TP=-1.5"
                        filename)
          (when (eq done 'feedback)
            (sacha-learn-lang-get-audio-feedback filename extra t)))))

;;;###autoload
  (defun sacha-learn-lang-process-latest-recording (annotation)
    (interactive "MAnnotation: ")
    (let* ((file (sacha-latest-file sacha-recordings-dir))
           (audio (expand-file-name
                   (concat (file-name-base file) "-" annotation ".opus")
                   "~/sync/recordings/")))
      (make-process :name "whisperx"
                    :buffer (get-buffer-create "*whisperx*")
                    :command (list
                              "bash"
                              "-c"
                              (format
                               "ffmpeg -y -i %s %s; cd ~/sync/recordings; ~/bin/whisperx %s"
                               (shell-quote-argument file)
                               (shell-quote-argument audio)
                               (shell-quote-argument audio))))
      (message "Started %s" audio)))

require('dotenv').config();
const { google } = require('googleapis');

async function download(fileId) {
  const auth = new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/drive.readonly'],
  });
  const drive = google.drive({ version: 'v3', auth });
  const htmlRes = await drive.files.export({
    fileId: fileId,
    mimeType: 'text/html'
  });
  return htmlRes.data;
}

async function main() {
  console.log(await download(process.argv.length > 2 ? process.argv[2] : process.env['DOC_ID']));
}

main();

  (defvar sacha-google-doc-download-command
    (list "nodejs" (expand-file-name "~/bin/download-google-doc-html.cjs")))

;;;###autoload
  (defun sacha-google-doc-html (doc-id)
    (when (string-match "https://docs\\.google\\.com/document/d/\\(.+?\\)/" doc-id)
      (setq doc-id (match-string 1 doc-id)))
    (with-temp-buffer
      (apply #'call-process (car sacha-google-doc-download-command)
             nil t nil (append (cdr sacha-google-doc-download-command) (list doc-id)))
      (buffer-string)))

(require 'dom)
;;;###autoload
(defun sacha-google-doc-clean-html (html)
  "Remove links on spaces, replace Google links."
  (let ((dom (with-temp-buffer
               (insert html)
               (libxml-parse-html-region))))
    (dom-search
     dom
     (lambda (o)
       (when (eq (dom-tag o) 'a)
         (when (and (dom-attr o 'href)
                    (string-match "https://\\(www\\.\\)?google\\.com/url\\?q=" (dom-attr o 'href)))
           (let* ((parsed (url-path-and-query
                           (url-generic-parse-url (dom-attr o 'href))))
                  (params (url-parse-query-string (cdr parsed))))
             (dom-set-attribute o 'href (car (assoc-default "q" params #'string=)))))
         (let ((text (string= (string-trim (dom-text o)) "")))
           (when (string= text "")
             (setf (car o) 'span))))
       (when (and
              (string-match "font-weight:700" (or (dom-attr o 'style) ""))
              (not (string-match "font-style:normal" (or (dom-attr o 'style) ""))))
         (setf (car o) 'strong))
       (when (dom-attr o 'style)
         (dom-remove-attribute o 'style))))
    ;; bold text is actually represented as font-weight:700 instead
    (with-temp-buffer
      (svg-print dom)
      (buffer-string))))

;;;###autoload
  (defun sacha-google-doc-org (doc-id)
    "Return DOC-ID in Org Mode format."
    (pandoc-convert-stdio (sacha-google-doc-clean-html (sacha-google-doc-html doc-id)) "html" "org"))

;;;###autoload
  (defun sacha-org-get-subtree-by-name (org-text heading-name)
    "Return ORG-TEXT subtree for HEADING-NAME."
    (with-temp-buffer
      (insert org-text)
      (org-mode)
      (goto-char (point-min))
      (while (re-search-forward " " nil t)
        (replace-match " "))
      (goto-char (point-min))
      (let ((org-trust-scanner-tags t))
        (car (delq nil
                   (org-map-entries
                    (lambda ()
                      (when (string= (org-entry-get (point) "ITEM") heading-name)
                        (buffer-substring (point) (org-end-of-subtree))))))))))

  (defvar sacha-learn-lang-words-for-review-context-function 'sentence-at-point)
  (defvar sacha-learn-lang-tutor-notes-url nil)
;;;###autoload
  (defun sacha-learn-lang-tutor-notes (section-name)
    (sacha-org-get-subtree-by-name
     (sacha-google-doc-org sacha-learn-lang-tutor-notes-url)
     section-name))

;;;###autoload
  (defun sacha-learn-lang-words-for-review (section)
    "List the bolded words for review in SECTION."
    (let* ((section (sacha-learn-lang-tutor-notes section))
           results)
      (with-temp-buffer
        (insert section)
        (org-mode)
        (goto-char (point-min))
        (org-map-entries
         (lambda ()
           (org-end-of-meta-data t)
           (unless (looking-at org-heading-regexp)
             (let ((end (save-excursion (org-end-of-subtree))))
               (while (re-search-forward "\\*[^* ].*?\\*" end t)
                 (cl-pushnew
                  (replace-regexp-in-string
                   "[ \n ]+" " "
                   (funcall sacha-learn-lang-words-for-review-context-function))
                  results
                  :test 'string=)))))))
      (nreverse results)))

(sacha-learn-lang-words-for-review "Sur l'intelligence artificielle")

;;;###autoload
  (defun sacha-split-string-keep-delimiters (string delimiter)
    (when string
      (let (results pos)
        (with-temp-buffer
          (insert string)
          (goto-char (point-min))
          (setq pos (point-min))
          (while (re-search-forward delimiter nil t)
            (push (buffer-substring pos (match-beginning 0)) results)
            (setq pos (match-beginning 0)))
          (push (buffer-substring pos (point-max)) results)
          (nreverse results)))))

  (ert-deftest sacha-split-string-keep-delimiters ()
   (should
    (equal (sacha-split-string-keep-delimiters
            "Beaucoup de gens ont une réaction forte contre l'IA pour plusieurs raisons qui *incluent* le battage médiatique excessif dont elle fait l'objet, son utilisation à mauvais escient, et *l'inondation de banalité* qu'elle produit."
            ", \\| que \\| qui \\| qu'ils? \\| qu'elles? \\| qu'on "
            )
   )))

;;;###autoload
  (defun sacha-learn-lang-words-for-review-phrase-context (&optional s)
    (setq s (replace-regexp-in-string " " " " (or s (sentence-at-point))))
    (string-join
     (seq-keep
      (lambda (s)
        (when (string-match "\\*" s)
          (replace-regexp-in-string "^, " "" s)))
      (sacha-split-string-keep-delimiters s ", \\| parce que \\| que \\| qui \\| qu'ils? \\| qu'elles? \\| qu'on \\| pour "))
     " ... "))

  (ert-deftest sacha-learn-lang-words-for-review-phrase-context ()
    (should
     (equal (sacha-learn-lang-words-for-review-phrase-context
             "Je peux consacrer une petite partie de mon *budget* à des essais, mais je ne veux pas travailler davantage pour rentabiliser une dépense plus importante.")
            "Je peux consacrer une petite partie de mon *budget* à des essais")))

(let ((sacha-learn-lang-words-for-review-context-function 'sacha-learn-lang-words-for-review-phrase-context))
  (sacha-learn-lang-words-for-review "Sur l'intelligence artificielle"))

;;;###autoload
  (defun sacha-learn-lang-tutor-notes-wdiff-org ()
    (interactive)
    (let ((section (org-entry-get (point) "ITEM")))
      (sacha-wdiff-strings
       (replace-regexp-in-string
        " " " "
        (sacha-org-subtree-text-without-blocks))
       (replace-regexp-in-string
        org-link-bracket-re
        "\\2"
        (replace-regexp-in-string
         " " " "
         (sacha-learn-lang-tutor-notes section))))))

  (setq learn-lang-subed-record-reference-dir "~/proj/french/reference/")

  (with-eval-after-load 'subed-record
    (add-hook 'subed-record-finished-hook 'sacha-subed-record-normalize-current))

;;;###autoload
  (defun sacha-subed-record-normalize-current (file)
    (interactive (list (subed-media-file)))
    (let ((temp-file (make-temp-file file nil (concat "." (file-name-extension file)))))
      (make-process
       :name "normalize"
       :buffer (get-buffer-create "*normalize*")
       :command (list
                 (expand-file-name "~/bin/normalize")
                 (expand-file-name file)
                 temp-file)
       :sentinel
       (lambda (process event)
         (when (string-match "finished" event)
           (rename-file temp-file file t)
           (message "Normalized %s" file))))))

  (defvar-local sacha-subed-record-references nil)
;;;###autoload
  (defun sacha-subed-record-load-references (file &optional skip-insert)
    "Load the references from FILE (media)."
    (interactive (list (read-file-name "Media file: ")
                       current-prefix-arg))
    (dolist (cue (subed-parse-file (concat (file-name-sans-extension file) ".vtt")))
      (push
       (list
        (learn-lang-subed-record-simplify (elt cue 3))
        file
        (elt cue 1)
        (elt cue 2))
       sacha-subed-record-references))
    (unless skip-insert
      (sacha-subed-insert-references)))

;;;###autoload
  (defun sacha-subed-record-insert-reference ()
    (interactive)
    (when-let* ((rec (alist-get (learn-lang-subed-record-simplify (subed-subtitle-text))
                               sacha-subed-record-references
                               nil nil #'string=)))
      (subed-record-set-directive
       "#+REFERENCE"
       (format "%s %s --> %s"
               (elt rec 0)
               (subed-msecs-to-timestamp (elt rec 1))
               (subed-msecs-to-timestamp (elt rec 2))))))

;;;###autoload
  (defun sacha-subed-insert-references ()
    (interactive)
    (subed-for-each-subtitle (point-min) (point-max) t
      (sacha-subed-record-insert-reference)))

;;;###autoload
  (defun sacha-learn-lang-word-timestamps ()
    "Add timestamps using the MFA French model."
    (interactive)
    (let ((subed-align-mfa-dictionary "french_mfa")
          (subed-align-mfa-acoustic-model "french_mfa"))
      (subed-align-mfa-set-word-data
       (subed-media-file)
       nil nil
       (lambda (&rest _)
         (subed-word-data-add-word-timestamps)))))

;;;###autoload
  (defun sacha-learn-lang-get-audio-feedback (filename &optional extra-text display)
    (interactive (list (if current-prefix-arg
                           (read-file-name "File: " sacha-learn-lang-practice-dir nil t nil
                                           (lambda (filename) (string-match "\\.m4a$" filename)))
                         (sacha-latest-file sacha-learn-lang-practice-dir "\\(\\.m4a\\|\\.webm\\)$"))
                       (if (region-active-p)
                           (buffer-substring (region-beginning) (region-end)))
                       t))
    (let* ((data
            (replace-regexp-in-string
             "\n" ""
             (shell-command-to-string (concat "base64 " (shell-quote-argument filename)))))
           (text
            (concat "Give me feedback in English on this recording of beginner French practice. I am a female A0/A1 speaker. Focus first on major mispronunciations, and provide English phonetic transcriptions for those words using italicized parenthetical notes.

  Return your response using Org Mode syntax using only list items, not headings. Do not put it in a code block, just return Org Mode text. For example, *bold*. Score it out of 10.

  Example output:

  - Pronunciation (7 /10)
    - travaillé /(trah vay yay)/
  "
                    (if extra-text
                        (concat "\n\n###\n\n" extra-text)
                      "")))
           (json-array-type 'vector)
           (json-object-type 'alist)
           (body (json-encode
                  `(("contents"
                     (("parts" .
                       ((("text" . ,text))
                        (("inline_data" .
                          (("mime_type" . "audio/mp4")
                           ("data" . ,data))))
                        )))))))
           result)
      (setq
       result
       (plz 'post "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent"
         :headers
         `(("Content-Type" . "application/json")
           ("X-goog-api-key" . ,sacha-gemini-api-key))
         :as #'json-read
         :body body))
      (when display
        (with-current-buffer (get-buffer-create "*Feedback*")
          (org-mode)
          (goto-char (point-min))
          (let* ((text (map-nested-elt result '(candidates 0 content parts 0 text)))
                 (score (when (string-match "Pronunciation (\\(.+\\))" text) (match-string 1 text))))
            (insert "* " (org-link-make-string
                          (concat "audio:"
                                  (replace-regexp-in-string
                                   (rx line-start
                                       (literal (getenv "HOME")))
                                   "~"
                                   filename))
                          "me:") "  "
                          (or score "")
                          "\n"
                          text
                          "\n\n"))
          (display-buffer (current-buffer))
          (with-selected-window (get-buffer-window (current-buffer))
            (goto-char (point-min))
            (recenter-top-bottom 0))))
      (map-nested-elt result '(candidates 0 content parts 0 text))))

;;;###autoload
  (defun sacha-org-copy-clean-version (text)
    "Copy BEG to END without strike-throughs."
    (interactive (list (if (region-active-p) (buffer-substring (region-beginning) (region-end))
                         (sentence-at-point))))
    (let ((result
           (mapconcat (lambda (o)
                               (if (stringp o)
                                   o
                                 (car (org-element-contents o))))
                             (seq-remove (lambda (o)
                                           (and (listp o)
                                                (member (org-element-type o)
                                                        '(strike-through macro))))
                                         (org-element-parse-secondary-string
                                          text '(paragraph bold strike-through macro)))
                             " ")))
             (setq result
               (replace-regexp-in-string
                "  +" " "
                (replace-regexp-in-string " [\\.,]" "\\1" result)))
      (when (called-interactively-p 'any)
        (message "%s" result)
        (kill-new result))
      result))

;;;###autoload
  (defun sacha-audio-clip (source start-time end-time destination text)
    (interactive
     (let ((s (and (region-active-p) (buffer-substring (region-beginning) (region-end)))))
       (if (and s
                (string-match "\\(\\(?:\\(?:[0-9]+\\):\\)?\\(?:[0-9]+\\):\\(?:[0-9]+\\)\\(?:\\.\\(?:[0-9]+\\)\\)?\\)[ \n\t]+\\(\\(?:\\(?:[0-9]+\\):\\)?\\(?:[0-9]+\\):\\(?:[0-9]+\\)\\(?:\\.\\(?:[0-9]+\\)\\)?\\)" s))
           (let ((start (match-string 1 s))
                 (end (match-string 2 s)))
             (list
              (read-file-name "Source: " nil nil t)
              start
              end
              (read-file-name "Destination: ")
              (read-string "Text: ")))
         (list (read-file-name "Source: " nil nil t)
               (read-string "Start time: ")
               (read-string "End time: ")
               (read-file-name "Destination: ")
               (read-string "Text: ")))))
    (let ((result (call-process "ffmpeg" nil (get-buffer-create "*ffmpeg*") nil
                                "-y" ; Overwrite output file without asking
                                "-i" (expand-file-name source) ; Input file
                                "-ss" start-time ; Start time (e.g., 00:00:10)
                                "-to" end-time ; End time/Stop time
                                (expand-file-name destination))))
      (when result
        (when (region-active-p) (delete-region (region-beginning) (region-end)))
        (insert (org-link-make-string
                 (concat "audio:" (replace-regexp-in-string (getenv "HOME") "~" destination))
                 text)))))

;;;###autoload
  (defun sacha-learn-lang-write-journal-entries-for-subtree ()
    (interactive)
    (org-map-entries
     (lambda ()
       (when (org-entry-get (point) "DATE")
         (let ((text (replace-regexp-in-string "{.+?}" "" (sacha-org-subtree-text-without-blocks))))
           (with-temp-file (expand-file-name (concat (org-entry-get (point) "DATE") ".txt")
                                             "~/proj/french/journal")
             (insert text)))))
     nil 'tree))

(defvar sacha-learn-lang-en-fr-dictionary-file "~/proj/french/dic-en-fr.iso")
(defvar sacha-learn-lang-dictionary nil)
;;;###autoload
(defun sacha-learn-lang-load-dict ()
  (interactive)
  (with-temp-buffer
    (insert-file-contents sacha-learn-lang-en-fr-dictionary-file)
    (goto-char (point-min))
    (while (looking-at "^# ") (forward-line 1))
    (setq sacha-learn-lang-dictionary
          (seq-keep (lambda (s)
                      (when (string-match "^\\(.+?\\) {\\(.+?\\)}\\(?: /\\(.+?\\)/\\)?\\(?: (\\(.+?\\))\\)?\\( SEE: .+?\\)? ::\\(?: \\(.+?\\) *\\({.+}.*\\)?\\)?$" s)
                        (let ((headword (match-string 1 s))
                              (head-type (match-string 2 s))
                              (def (match-string 4 s))
                              (see (match-string 5 s))
                              (translation (match-string 6 s))
                              (types (match-string 7 s)))
                          (cons
                           (propertize (format "%s {%s} - %s - %s :: %s"
                                               headword
                                               head-type
                                               (or see translation)
                                               (or def "")
                                               (or types ""))
                                       'gender
                                       (cond
                                         ((null types) nil)
                                         ((string-match "^{m}" types) "m")
                                         ((string-match "^{f}" types) "f")))
                           translation))))
                    (split-string (buffer-substring (point) (point-max)) "\n")))
    (seq-take sacha-learn-lang-dictionary 10)))

;;;###autoload
(defun sacha-learn-lang-consult-en-fr ()
  (interactive)
  (unless sacha-learn-lang-dictionary (sacha-learn-lang-load-dict))
  (insert
   (consult--read
    (consult--dynamic-collection
        (lambda (input)
          (let (match-start
                match-any
                exact
                (search (regexp-quote input)))
            (seq-map (lambda (o)
                       (setf (car o)
                             (propertize
                              (car o)
                              'face
                              (list
                               :background
                               (pcase (get-text-property 0 'gender (car o))
                                 ('nil nil)
                                 ("m" (modus-themes-get-color-value 'bg-blue-subtle))
                                 ("f" (modus-themes-get-color-value 'bg-magenta-subtle))))))
                       (cond
                        ((string-match (concat "^" search " - ") (car o))
                         (push o exact))
                        ((string-match (concat "^" search) (car o))
                         (push o match-start))
                        ((string-match search (car o))
                         (push o match-any))))
                     sacha-learn-lang-dictionary)
            (append
             (nreverse exact)
             (nreverse match-start)
             (nreverse match-any)
             nil))))
    :sort nil
    :lookup #'consult--lookup-cdr)))

  (defvar sacha-learn-lang-wordreference-cache nil)

;;;###autoload
  (defun sacha-learn-lang-wordreference-completing-read ()
    (interactive)
    (consult--read
     (consult--dynamic-collection
         (lambda (input)
           (message "input: %s" input)
           (with-current-buffer
               (url-retrieve-synchronously
                (concat "https://www.wordreference.com/autocomplete?dict=enfr&query="
                        (url-hexify-string input)))
                               (set-buffer-multibyte t)
             (goto-char (point-min))
             (re-search-forward "^$" nil t)
             (prog1
                 (mapcar (lambda (row)
                           (let ((fields (split-string row "\t")))
                             (propertize
                              (format "%s (%s)"
                                      (car fields)
                                      (cadr fields))
                              'consult--candidate
                              fields)))
                         (split-string
                          (string-trim (buffer-substring (point) (point-max))) "\n"))
               (kill-buffer (current-buffer))))))
     :sort nil
     :initial (symbol-name (symbol-at-point))
     :history 'sacha-learn-lang-wordreference-lookup-history
     :prompt "Word: "
     :category 'word))

  (defvar-keymap sacha-learn-lang-wordreference-keymap
    "v" #'sacha-spookfox-scroll-down
    "V" #'sacha-spookfox-scroll-up
    "c" #'sacha-learn-lang-conjugate-last-word
    "l" #'sacha-learn-lang-wordreference-lookup)

  (defvar sacha-learn-lang-wordreference-lookup-history nil)
;;;###autoload
  (defun sacha-learn-lang-wordreference-lookup (word)
    (interactive (list (sacha-learn-lang-wordreference-completing-read)))
    (let (language)
      (if (string-match " (\\(en\\|fr\\))" word)
          (setq language (match-string 1 word)
                word (replace-match "" nil t word 0)))
      (setq word (replace-regexp-in-string "^#" "" word))
      (browse-url
       (format "https://www.wordreference.com/%s/%s"
               (if (string= language "fr")
                   "fren"
                 "enfr")
               (url-hexify-string word))))
    (set-transient-map sacha-learn-lang-wordreference-keymap t))

;;;###autoload
  (defun sacha-learn-lang-conjugate-last-word ()
    (interactive)
    (grammalecte-conjugate-verb
     (replace-regexp-in-string " (.+)" ""
                               (car sacha-learn-lang-wordreference-lookup-history))))

;;;###autoload
  (defun sacha-learn-lang-wordreference-conjugate (word)
    (interactive (list (sacha-learn-lang-wordreference-completing-read)))
    (browse-url (concat "https://www.wordreference.com/conj/frverbs.aspx?v="
                        (url-hexify-string (if (listp word) (car word) word)))))

;;;###autoload
  (defun sacha-learn-lang-reverso (s)
    (interactive (list (if (region-active-p)
                           (buffer-substring (region-beginning) (region-end))
                         (word-at-point))))
    (browse-url (concat "https://www.reverso.net/text-translation#sl=fra&tl=eng&text="
                        (url-hexify-string s))))