General Org-Mode Configuration

(defun ha-org-return ()
  "If at the end of a line, do something special based on the
 information about the line by calling `ha-org-special-return',
 otherwise, `org-return' as usual."
  (interactive)
  (if (eolp)
      (ha-org-special-return)
    (org-return)))

(define-key org-mode-map (kbd "RET")  #'ha-org-return)

(defun ha-org-special-return (&optional ignore)
  "Add new list item with RET.
A double return on an empty element deletes it.
Use a prefix arg to get regular RET."
  (interactive "P")
  (if ignore
      (org-return)
    (cond
     ;; Open links like usual
     ((eq 'link (car (org-element-context)))
      (org-return))

     ((and (org-really-in-item-p) (not (bolp)))
      (if (org-element-property :contents-begin (org-line-element-context))
          (progn
            (end-of-line)
            (org-insert-item))
        (delete-region (line-beginning-position) (line-end-position))))

     (t
      (org-return)))))

(defun org-really-in-item-p ()
  "Return item beginning position when in a plain list, nil otherwise.
Unlike `org-in-item-p', this works around an issue where the
point could actually be in some =code= words, but still be on an
item element."
  (save-excursion
    (let ((location (org-element-property :contents-begin (org-line-element-context))))
      (when location
        (goto-char location))
      (org-in-item-p))))

(defun org-line-element-context ()
  "Return the symbol of the current block element, e.g. paragraph or list-item."
  (let ((context (org-element-context)))
    (while (member (car context) '(verbatim code bold italic underline))
      (setq context (org-element-property :parent context)))
    context))

(setq org-todo-keywords '((sequence "TODO(t)" "DOING(g)" "|" "DONE(d)")
                          (sequence "BLOCKED(b)" "|" "CANCELLED(c)")))

(defun ha-org-clock-todo-change ()
  "Called from hook `org-after-todo-state-change-hook'.
Clock in if a task changes to DOING (i.e. IN_PROGRESS),
and clocks out with any other state change."
  (if (string= org-state "DOING")
      (org-clock-in)
    (org-clock-out-if-current)))

(add-hook 'org-after-todo-state-change-hook 'ha-org-clock-todo-change)

(dolist (m '(org-mode org-journal-mode))
  (font-lock-add-keywords m                        ; A bit silly but my headers are now
                          `(("^\\*+ \\(TODO\\) "   ; shorter, and that is nice canceled
                             (1 (progn (compose-region (match-beginning 1) (match-end 1) "⚑") nil)))
                            ("^\\*+ \\(DOING\\) "
                             (1 (progn (compose-region (match-beginning 1) (match-end 1) "⚐") nil)))
                            ("^\\*+ \\(CANCELED\\) "
                             (1 (progn (compose-region (match-beginning 1) (match-end 1) "✘") nil)))
                            ("^\\*+ \\(BLOCKED\\) "
                             (1 (progn (compose-region (match-beginning 1) (match-end 1) "✋") nil)))
                            ("^\\*+ \\(DONE\\) "
                             (1 (progn (compose-region (match-beginning 1) (match-end 1) "✔") nil)))
                            ;; Here is my approach for making the initial asterisks for listing items and
                            ;; whatnot, appear as Unicode bullets ;; (without actually affecting the text
                            ;; file or the behavior).
                            ("^ +\\([-*]\\) "
                             (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•")))))))

(defun meeting-notes ()
    "Call this after creating an org-mode heading for where the notes for the meeting
     should be. After calling this function, call 'meeting-done' to reset the environment."
      (interactive)
      (outline-mark-subtree)                             ; Select org-mode section
      (narrow-to-region (region-beginning) (region-end)) ; Show that region
      (deactivate-mark)
      (delete-other-windows)                             ; remove other windows
      (text-scale-set 2)                                 ; readable by others
      (fringe-mode 0)
      (message "When finished taking your notes, run meeting-done."))

(defun meeting-done ()
      "Attempt to 'undo' the effects of taking meeting notes."
      (interactive)
      (widen)                    ; Opposite of narrow-to-region
      (text-scale-set 0)         ; Reset the font size increase
      (fringe-mode 1)
      (winner-undo))             ; Put the windows back in place

(use-package org-find-file
  :straight nil
  :config
  (ha-leader "f o" '("load org" . org-find-file)))

(defun ha-search-notes--macos (phrase path)
  "Return the indexed search system command on MACOS, mdfind.
Including the parameters using the PHRASE on the PATH(s)."
  (let ((paths (if (listp path)
                   (mapconcat (lambda (p) (concat "-onlyin " p)) path " ")
                 (concat "-onlyin " path))))
    (format "mdfind %s -interpret %s" paths phrase)))

(defun ha-search-notes--linux (phrase path)
  "Return the indexed search system command on Linux, recoll.
Including the parameters using the PHRASE on the PATH(s)."
    (format "recoll -t -a -b %s" phrase))

(ha-search-notes--macos "crossway stream" "~/Notes")

(defun ha-search-notes--files (phrase path)
  "Return an escaped string of all files matching PHRASE.
On a Mac, the PATH limits the scope of the search."
  (let ((command (if (ha-running-on-macos?)
                     (ha-search-notes--macos phrase path)
                   (ha-search-notes--linux phrase path))))
    (->> command
         (shell-command-to-list)
         (--remove (s-matches? "~$" it))
         (--remove (s-matches? "#" it))
         (--map (format "'%s'" it))
         (s-join " "))))

(ha-search-notes--files "openstack grafana" '("~/Notes"))

(defun ha-search-notes (phrase &optional path)
  "Search files in PATH for PHRASE and display in a grep mode buffer."
  (interactive "sSearch notes for: ")
  (let* ((command   (if (ha-running-on-macos?) "ggrep" "grep"))
         (regexp    (string-replace " " "\\|" phrase))
         (use-paths (or path (list org-directory org-journal-dir)))
         (files     (ha-search-notes--files phrase use-paths))
         (cmd-line  (format "%s -ni -m 1 '%s' %s" command regexp files)))
    (grep cmd-line)))

(ha-leader "f n" '("find notes" . ha-search-notes))

(ha-leader
  "o l" '("store link"  . org-store-link)
  "o x" '("org capture" . org-capture)
  "o C" '("clock out"   . org-clock-out))

(ha-leader :keymaps 'org-mode-map
  "o h" '("go headings" . consult-org-heading)
  "o e" '("exports"     . org-export-dispatch)
  "o L" '("insert link" . org-insert-link)
  "o P" '("set property" .  org-set-property)
  "o g" '("set tags" .  org-set-tags-command)
  "o t" '("todo" . org-todo)
  "o T" '("list todos" .  org-todo-list)

  "o i"  '(:ignore t :which-key "insert")
  "o i i" '("item" .  org-insert-item)
  "o i I" '("insert id" .  org-id-get-create)
  "o i l" '("link" .  org-insert-link)
  "o i d" '("drawer" .  org-insert-drawer)
  "o i h" '("heading" .  org-insert-heading)
  "o i s" '("subheading" .  org-insert-subheading)

  "o o"  '(:ignore t :which-key "toggles")
  "o o h" '("heading" .  org-toggle-heading)
  "o o i" '("item" .  org-toggle-item)
  "o o x" '("checkbox" .  org-toggle-checkbox)
  "o o I" '("images" .  org-toggle-inline-images)
  "o o m" '("markup" . (lambda () (interactive)
                          (setq org-hide-emphasis-markers (not org-hide-emphasis-markers)) (font-lock-update)))

  "o /" '("agenda" . consult-org-agenda)
  "o '" '("edit" . org-edit-special)
  "o *" '("C-c *" . org-ctrl-c-star)
  "o +" '("C-c -" . org-ctrl-c-minus)

  "o c"  '(:ignore t :which-key "clocks")
  "o c i" '("clock in" . org-clock-in)
  "o c l" '("clock in last" . org-clock-in-last)
  "o c o" '("clock out" . org-clock-out)
  "o c c" '("cancel" . org-clock-cancel)
  "o c d" '("mark default task" . org-clock-mark-default-task)
  "o c e" '("modify effort" . org-clock-modify-effort-estimate)
  "o c E" '("set effort" . org-set-effort)
  "o c g" '("goto clock" . org-clock-goto)
  "o c r" '("resolve clocks" . org-resolve-clocks)
  "o c R" '("clock report" . org-clock-report)
  "o c t" '("eval range" . org-evaluate-time-range)
  "o c =" '("timestamp up" . org-clock-timestamps-up)
  "o c -" '("timestamp down" . org-clock-timestamps-down)

  "o d"  '(:ignore t :which-key "dates")
  "o d s" '("schedule" . org-schedule)
  "o d d" '("deadline" . org-deadline)
  "o d t" '("timestamp" . org-time-stamp)
  "o d T" '("inactive time" . org-time-stamp-inactive)


  "o b"  '(:ignore t :which-key "tables")
  "o b -" '("insert hline" . org-table-insert-hline)
  "o b a" '("align" . org-table-align)
  "o b b" '("blank field" . org-table-blank-field)
  "o b c" '("create teable" . org-table-create-or-convert-from-region)
  "o b e" '("edit field" . org-table-edit-field)
  "o b f" '("edit formula" . org-table-edit-formulas)
  "o b h" '("field info" . org-table-field-info)
  "o b s" '("sort lines" . org-table-sort-lines)
  "o b r" '("recalculate" . org-table-recalculate)
  "o b d"  '(:ignore t :which-key "delete")
  "o b d c" '("delete column" . org-table-delete-column)
  "o b d r" '("delete row" . org-table-kill-row)
  "o b i"  '(:ignore t :which-key "insert")
  "o b i c" '("insert column" . org-table-insert-column)
  "o b i h" '("insert hline" . org-table-insert-hline)
  "o b i r" '("insert row" . org-table-insert-row)
  "o b i H" '("insert hline ↓" . org-table-hline-and-move)

  "o n"  '(:ignore t :which-key "narrow")
  "o n s" '("subtree" . org-narrow-to-subtree)
  "o n b" '("block"   . org-narrow-to-block)
  "o n e" '("element" . org-narrow-to-element)
  "o n w" '("widen"   . widen))

(when (fboundp 'evil-define-key)
  (evil-define-key '(normal motion operator visual)
    org-mode-map
    "gj" '("next heading" . #'org-forward-heading-same-level)
    "gk" '("prev heading" . #'org-backward-heading-same-level)
    "gb" '("next block" . #'org-next-block)
    "gB" '("prev block" . #'org-previous-block)))

(setq org-export-backends '(ascii html icalendar md odt))

(use-package ox-confluence
  :after org
  :straight nil   ; Located in my "elisp" directory
  :config
  (ha-leader :keymaps 'org-mode-map
    "o E" '("to confluence"     . ox-export-to-confluence)))

(use-package graphviz-dot-mode
    :mode "\\.dot\\'"
    :init
    (setq tab-width 4
          graphviz-dot-indent-width 2
          graphviz-dot-auto-indent-on-newline t
          graphviz-dot-auto-indent-on-braces t
          graphviz-dot-auto-indent-on-semi t))

(use-package async)

(use-package ha-focus
  :straight (:type built-in)
  :config
  (ha-leader
   "o f" '("begin focus" . ha-focus-begin)
   "o F" '("break focus" . ha-focus-break)))

(defvar-local ha-sentence-buffer nil
  "The name of the buffer to return when completed.")
(defvar-local ha-sentence-begin nil
  "The beginning position in the original buffer to replace text.")
(defvar-local ha-sentence-end nil
  "The ending position in the original buffer to replace text.")

(defun ha-sentence--select-region (type-of-thing &optional start end)
  "Return a tuple of the start and end of the selected sentence."
  (cond
   ((region-active-p) (cons (region-beginning) (region-end)))
   ((and start end)   (cons start end))
   (t                 (bounds-of-thing-at-point type-of-thing))))

(defun ha-sentence-break (&optional start end)
  "Break a sentence out and work it in a new buffer.
  A sentence chosen is based on the location of a point,
  or the active region."
  (interactive)
  (cl-destructuring-bind (start . end) (ha-sentence--select-region 'sentence start end)
    (let ((orig-mode major-mode)
          (orig-buffer (current-buffer))
          (orig-sentence (buffer-substring-no-properties start end)))

      (switch-to-buffer-other-window "**sentence-breakout**")
      (funcall orig-mode)
      (ha-sentence-buffer-mode)

      ;; Store some breadcrumbs so we can return where we left off:
      (setq-local ha-sentence-buffer orig-buffer
                  ha-sentence-begin start
                  ha-sentence-end end)
      (erase-buffer)
      (insert orig-sentence)

      ;; Because we might want to duplicate the sentence in the
      ;; buffer, let's put it on the kill ring:
      (kill-new orig-sentence))))

(defun ha-sentence-choose (&optional start end)
  "Choose a sentence and go back to the other window."
  (interactive)

  ;; By default, our "region" is a paragraph using 'defun symbol of `thing-at-point'
  ;; It doesn't work on the last sentence if it doesn't include a
  ;; newline, so hackily, we insert one.
  (save-excursion
    (goto-char (point-max))
    (insert "\n"))

  (cl-destructuring-bind (start . end) (ha-sentence--select-region 'defun start end)
    (let ((chosen-sentence (buffer-substring-no-properties start end))
          (orig-buffer     ha-sentence-buffer)
          (orig-start      ha-sentence-begin)
          (orig-end        ha-sentence-end))

      (kill-buffer-and-window)
      (switch-to-buffer orig-buffer)
      (delete-region orig-start orig-end) ; Or call `kill-region' to put on clipboard?
      (insert chosen-sentence))))

(defun ha-sentence-duplicate ()
  (interactive)
  (let ((current (thing-at-point 'defun)))
    (goto-char (point-max))
    (insert "\n\n")
    (let ((starting-point (point)))
      (insert current)
      (goto-char starting-point))))

(defvar ha-sentence-buffer-mode-map (make-sparse-keymap) "Keymap for `my-mode'.")
(define-key ha-sentence-buffer-mode-map (kbd "C-c C-c") #'ha-sentence-choose)
(define-key ha-sentence-buffer-mode-map (kbd "C-c C-k") #'kill-buffer-and-window)
(define-key ha-sentence-buffer-mode-map (kbd "C-c C-d") #'ha-sentence-duplicate)

(define-minor-mode ha-sentence-buffer-mode
  "Toggle the Perfect Sentence mode.
Interactively with no argument, this command toggles the mode.
A positive prefix argument enables the mode, any other prefix
argument disables it.  From Lisp, argument omitted or nil enables
the mode, `toggle' toggles the state.

When this mode is enabled, `C-c C-c' calls `ha-sentence-choose',
and `C-c C-k' cancels and buries the buffer."
  ;; :interactive nil
  :init-value nil
  :lighter " PS"
  :keymap ha-sentence-buffer-mode-map)

(global-set-key (kbd "M-s b") 'ha-sentence-break)

(ha-leader "x b" '("edit sentence" . ha-sentence-break))