#어젠다: 텍스트로 당신의 인생을 설계하라 - norang

;;; -*- mode: emacs-lisp; coding: utf-8; lexical-binding: t -*-
;;
;; Copyright (c) 2012-2023 Sylvain Benner & Contributors
;;
;; Author: Junghan Kim <junghanacs@gmail.com>
;; URL: https://github.com/junghanacs
;;
;; This file is not part of GNU Emacs.
;;
;; License: GPLv3

;;; Commentary:

;;; Code:

(defconst jh-org-workflow-packages
  '(
    org
    ))

;;;; 'post-init-org' Load org-workflow

(defun jh-org-workflow/post-init-org ()

;;;; Getting Stated

노랑님 바인딩 예

;; from DW
(evil-define-key '(normal insert visual) org-mode-map (kbd "C-n")
  'org-next-visible-heading)
(evil-define-key '(normal insert visual) org-mode-map (kbd "C-p")
  'org-previous-visible-heading)

;; =C-c %= org-mark-ring-push, =C-c &= org-mark-ring-goto
;; =C-c @= org-mark-subtree
;; https://orgmode.org/manual/Handling-Links.html
;; (define-key org-mode-map (kbd "C-M-n") 'org-next-link)
;; (define-key org-mode-map (kbd "C-M-p") 'org-previous-link)

(global-set-key (kbd "C-c l") 'org-store-link)
(global-set-key (kbd "C-c i") 'org-insert-link)
(global-set-key (kbd "C-c a") 'org-agenda)
(global-set-key (kbd "C-c c") 'org-capture)
(global-set-key (kbd "C-c \\") 'org-tags-sparse-tree)

;; The following setting is different from the document so that you
;; can override the document org-agenda-files by setting your
;; org-agenda-files in the variable org-user-agenda-files
(if (boundp 'org-user-agenda-files)
    (setq org-agenda-files org-user-agenda-files)
  (setq org-agenda-files (quote ("~/org/inbox.org"))))

(if (boundp 'org-user-agenda-diary-file)
    (setq org-agenda-diary-file org-user-agenda-diary-file)
  (setq org-agenda-diary-file "~/org/diary.org"))

(setq diary-file org-agenda-diary-file)

;; unset old key
(global-unset-key (kbd "<f4>"))
(global-unset-key (kbd "<f5>"))
(global-unset-key (kbd "<f6>"))
(global-unset-key (kbd "<f9>"))

;; Custom Key Bindings
;; (global-set-key (kbd "<f12>") 'org-agenda)
;; (global-set-key (kbd "<f5>") 'bh/org-todo)
;; (global-set-key (kbd "<S-f5>") 'bh/widen)
;; (global-set-key (kbd "<f7>") 'bh/set-truncate-lines)
;; (global-set-key (kbd "<f8>") 'org-cycle-agenda-files)

(global-set-key (kbd "<f9> <f9>") 'bh/show-org-agenda)
;; (global-set-key (kbd "<f9> b") 'bbdb)
(global-set-key (kbd "<f9> c") 'calendar)
;; (global-set-key (kbd "<f9> f") 'logos-focus-mode)
;; (global-set-key (kbd "<f9> g") 'gnus)
(global-set-key (kbd "<f9> h") 'bh/hide-other)
(global-set-key (kbd "<f9> n") 'bh/toggle-next-task-display)

(global-set-key (kbd "<f9> I") 'bh/punch-in)
(global-set-key (kbd "<f9> O") 'bh/punch-out)

(global-set-key (kbd "<f9> o") 'bh/make-org-scratch)
(global-set-key (kbd "<f9> s") 'bh/switch-to-scratch)

(global-set-key (kbd "<f9> t") 'bh/insert-inactive-timestamp)
(global-set-key (kbd "<f9> T") 'bh/toggle-insert-inactive-timestamp)

(global-set-key (kbd "<f9> v") 'visible-mode)

;; with markdown-mode-map
;; (define-key org-mode-map (kbd "<f9> l") 'org-toggle-link-display)
;; (define-key org-mode-map (kbd "<f9> g") 'org-toggle-inline-images)
(define-key org-mode-map (kbd "<f4>") 'org-toggle-link-display)
(define-key org-mode-map (kbd "<f5>") 'org-toggle-inline-images)
;; (global-set-key (kbd "M-<f9>") 'org-toggle-inline-images)

(global-set-key (kbd "<f9> i") 'org-clock-in)
(global-set-key (kbd "<f9> SPC") 'bh/clock-in-last-task)
(global-set-key (kbd "C-x n r") 'narrow-to-region)

(global-set-key (kbd "C-<f9>") 'previous-buffer)
(global-set-key (kbd "C-<f10>") 'next-buffer)

(global-set-key (kbd "<f11>") 'org-clock-goto)
(global-set-key (kbd "C-<f11>") 'org-clock-in)
;; (global-set-key (kbd "C-s-<f12>") 'bh/save-then-publish)

(defun bh/hide-other ()
  (interactive)
  (save-excursion
    (org-back-to-heading 'invisible-ok)
    (hide-other)
    (org-cycle)
    (org-cycle)
    (org-cycle)))

(defun bh/set-truncate-lines ()
  "Toggle value of truncate-lines and refresh window display."
  (interactive)
  (setq truncate-lines (not truncate-lines))
  ;; now refresh window display (an idiom from simple.el):
  (save-excursion
    (set-window-start (selected-window)
                      (window-start (selected-window)))))

(defun bh/make-org-scratch ()
  (interactive)
  (find-file "/tmp/publish/scratch.org")
  (gnus-make-directory "/tmp/publish"))

(defun bh/switch-to-scratch ()
  (interactive)
  (switch-to-buffer "*scratch*"))

;; Bookmark handling

(global-set-key (kbd "<C-f6>") (lambda() (interactive) (bookmark-set "SAVED")))
(global-set-key (kbd "<f6>") (lambda () (interactive) (bookmark-jump "SAVED")))

;; (setq ob-async-no-async-languages-alist '("gnuplot")) ; "mermaid"

;; 자주 쓰는 키 바인딩
(evil-define-key '(normal insert visual) org-mode-map (kbd "C-c H") 'org-insert-heading)
(evil-define-key '(normal insert visual) org-mode-map (kbd "C-c S") 'org-insert-subheading)

;; insert 모드에서 방향키로 쓰도록 세팅한다. evil-xxx-line 대신
;; 이맥스 기본 이동으로 세팅 했다.
;; (evil-define-key '(insert) org-mode-map (kbd "C-h") 'left-char)
;; (evil-define-key '(insert) org-mode-map (kbd "C-l") 'right-char)
;; (evil-define-key '(insert) org-mode-map (kbd "C-j") 'next-line)
;; (evil-define-key '(insert) org-mode-map (kbd "C-k") 'previous-line)

;; 이상하게 기존 키 바인딩이 안지워진다. 이건 나중에 다시 하자.
;; (define-key org-mode-map (kbd "M-h") nil)

;; (define-key org-mode-map (kbd "M-l>") nil)
;; (keymap-unset-key [M-h] "evil-mode")
;; (keymap-unset-key [M-l] "evil-mode")
;; (evil-define-key '(insert) org-mode-map (kbd "M-h") 'delete-backward-char)
;; (evil-define-key '(insert) org-mode-map (kbd "M-l") 'delete-forward-char)

;; 복사한 링크는 아래의 방법으로 넣는다. 깔끔해서 좋다.
;; org-cliplink 는 insert 니까 i를 바인딩한다. org-insert-link를 따른다.
(evil-define-key '(normal insert visual) org-mode-map (kbd "C-c M-i") 'org-cliplink)
;; (define-key map (kbd "C-c M-i") 'org-cliplink)

;; M-RET 마이너모드 커맨드 , 와 같음

;; ordered/unordered list 를 입력 할 때 편함.
;; 체크박스가 있는 경우 M-S-RET org-insert-todo-heading 을 활용.
(evil-define-key '(normal insert visual) org-mode-map (kbd "C-M-<return>") 'org-insert-item)

;; 문단을 한 라인으로 합쳐 준다. 구글 번역기 돌릴 때 매우 유용.
;; (evil-define-key '(normal insert visual) org-mode-map (kbd "C-M-q") 'unfill-paragraph)

;; org-timer 도 어젠다에 넣어주고 싶은데?!
;; clock-in 은 되는데 헤딩이 어젠다에 없는거면 소용 없다.
;; 내 생각엔 신경쓰지말고 완료 상태 만드는거에 집중하자.
;; (defun my/org-timer-set-hook ()
;;   ;; 일단 90분으로 고정
;;   (shell-command-to-string "~/.local/bin/set-timer.sh 90min")
;;   ;; (org-clock-in)
;;   )

;; (defun my/org-timer-stop-hook ()
;;   (shell-command-to-string "~/.local/bin/reset-timer.sh")
;;   ;; (org-clock-out)
;;   )

;; (defun my/org-timer-done-hook ()
;;   (shell-command-to-string "~/.local/bin/reset-timer.sh")
;;   ;; (org-clock-out)
;;   )

;; (add-hook 'org-timer-set-hook 'my/org-timer-set-hook)
;; (add-hook 'org-timer-done-hook 'my/org-timer-done-hook)
;; (add-hook 'org-timer-stop-hook 'my/org-timer-stop-hook)

;; my org pomodoro 실행 함수를 만들고, 거기서 셋팅하면 된다.
;; 이맥스 클라이언트로 동작시킬 필요가 없다.
;; (defun my/org-pomodoro()
;;   "my/org-pomodoro start w/ clock-in or stop"
;;   (interactive)
;;   (shell-command-to-string "~/.local/bin/set-timer.sh 25min")
;;   (org-pomodoro)
;;   )
;; (defun my/org-pomodoro-killed ()
;;   "my org-pomodoro-killed with i3-bar."
;;   (interactive)
;;   (shell-command-to-string "~/.local/bin/reset-timer.sh")
;;   (org-pomodoro-killed)
;;   )
;; (defun my/org-pomodoro-finished ()
;;   "my org-pomodoro-finished with i3-bar."
;;   (interactive)
;;   (shell-command-to-string "~/.local/bin/reset-timer.sh")
;;   (org-pomodoro-finished)
;;   )
;; (let ((map global-map))
;;   (define-key map (kbd "C-c j p p") 'my/org-pomodoro)
;;   (define-key map (kbd "C-c j p k") 'my/org-pomodoro-killed)
;;   (define-key map (kbd "C-c j p f") 'my/org-pomodoro-finished)
;;   )

;; /ahyatt-dotfiles/.emacs.d/emacs.org:214
;; TEMPORARY, seems like this isn't getting autoloaded correctly.
(require 'org-duration)
(require 'org-element)

(setq org-pomodoro-length 25)
(setq org-pomodoro-short-break-length 5)
(setq org-pomodoro-long-break-length 20)
;; A pomodoro group is for a day, so after 8 hours of no activity, that's a group.
(setq org-pomodoro-expiry-time (* 60 8))

(defun ash/org-pomodoro-til-meeting ()
  "Run a pomodoro until the next 30 minute boundary."
  (interactive)
  (let ((org-pomodoro-length (mod (- 30 (cadr (decode-time (current-time)))) 30)))
    (org-pomodoro)))

;; I org-clock-in, P org-pomodoro
(add-hook 'org-agenda-mode-hook
          #'(lambda () (org-defkey org-agenda-mode-map (kbd "C-c I") 'org-pomodoro))
          'append)

(setq org-pomodoro-manual-break t) ; manualy break my focus time
(setq org-pomodoro-format "⌛ %s")
(setq org-pomodoro-short-break-format "😽 %s"
      org-pomodoro-long-break-format "🎼 %s")
(setq org-pomodoro-start-sound "~/.spacemacs.d/sounds/focus_bell.wav")
(setq org-pomodoro-short-break-sound "~/.spacemacs.d/sounds/three_beeps.wav")
(setq org-pomodoro-long-break-sound "~/.spacemacs.d/sounds/three_beeps.wav")
(setq org-pomodoro-finished-sound "~/.spacemacs.d/sounds/meditation_bell.wav")
(setq org-pomodoro-audio-player "/usr/bin/aplay")

;; emacs built-in org-timer
(setq org-clock-sound "~/.spacemacs.d/sounds/meditation_bell.wav")

(defun my/play-meditation-bell()
  "Play meditation-bell"
  (interactive)
  (call-process-shell-command "~/.local/bin/play-meditation-bell.sh" nil 0) ; async
  )

(defun my/play-meditation-bell-short()
  "Play meditation-bell-short (focus)"
  (interactive)
  (call-process-shell-command "~/.local/bin/play-meditation-bell-short.sh" nil 0)
  )

(global-set-key (kbd "C-c j m") 'my/play-meditation-bell)

(add-hook 'org-clock-in-hook 'my/play-meditation-bell 'append)
;; (add-hook 'org-clock-out-hook 'my/play-meditation-bell 'append)
;; (add-hook 'org-clock-goto-hook 'my/play-meditation-bell 'append)
;; (add-hook 'org-clock-cancel-hook 'my/play-meditation-bell 'append)
;; (add-hook 'org-capture-mode-hook 'my/play-meditation-bell 'append)

;;;; Tasks and States

The triggers break down to the following rules:
Moving a task to CANCELLED adds a CANCELLED tag
Moving a task to WAITING adds a WAITING tag
Moving a task to HOLD adds WAITING and HOLD tags
Moving a task to a done state removes WAITING and HOLD tags
Moving a task to TODO removes WAITING, CANCELLED, and HOLD tags
Moving a task to NEXT removes WAITING, CANCELLED, and HOLD tags
Moving a task to DONE removes WAITING, CANCELLED, and HOLD tags

;; keys mentioned in brackets are hot-keys for the States
;; ! indicates insert timestamp
;; @ indicates insert note
;; / indicates entering the state
(setq org-todo-keywords
      (quote ((sequence "TODO(t)" "NEXT(n)" "|" "DONE(d)")
              (sequence "WAITING(w@/!)" "HOLD(h@/!)" "|" "OFF(o)" "CANCELLED(c@/!)" "PHONE(p)" "MEETING(m)")
              (sequence ; from doom-emacs
               "[ ](T)"   ; A task that needs doing
               "[-](N)"   ; Task is in progress
               "[?](W)"   ; Task is being held up or paused
               "|"
               "[X](D)")  ; Task was completed
              )))

(defface my/org-bold-todo
  '((t :inherit (bold org-todo)))
  "Face for bold TODO-type Org keywords.")

(defface my/org-bold-done
  '((t :inherit (bold org-done)))
  "Face for bold DONE-type Org keywords.")

(defface my/org-bold-next
  '((t :inherit (bold org-todo) :foreground "royal blue" ))
  "Face for bold NEXT-type Org keywords.")

(defface my/org-bold-shadow
  '((t :inherit (bold shadow)))
  "Face for bold and `shadow' Org keywords.")

(defface my/org-todo-special
  '((t :inherit (font-lock-keyword-face bold org-todo)))
  "Face for special TODO-type Org keywords.")

(setq org-todo-keyword-faces
      '(
        ("TODO" . my/org-bold-todo)
        ;; ("FIXME" . my/org-bold-todo)
        ("[ ]" . my/org-bold-todo)

        ("NEXT" . my/org-bold-next)

        ("DONE" . my/org-bold-done)
        ;; ("FIXED" . my/org-bold-done)
        ("[X]" . my/org-bold-done)
        ("CANCELLED" . my/org-bold-done)

        ("READ" . my/org-todo-special)
        ("[-]" . my/org-todo-special)
        ("MEETING" . my/org-todo-special)
        ("PHONE" . my/org-todo-special)

        ("WAITING" . my/org-bold-shadow)
        ("HOLD" . my/org-bold-shadow)
        ("[?]" . my/org-bold-shadow)
        ("OFF" . my/org-bold-shadow)
        )
      )

;; from doom-emacs
(setq org-eldoc-breadcrumb-separator " → ")
(setq org-priority-faces
      '((?A . error)
        (?B . warning)
        (?C . success)))

;; (setq org-use-fast-todo-selection t) ; default auto
;; (setq org-use-fast-tag-selection t) ; default auto

;; Shift 거슬리는 것을 막아주는 아주 요긴한 설정이다.
(setq org-treat-S-cursor-todo-selection-as-state-change nil)

;; org tage state manager
(setq org-todo-state-tags-triggers
      (quote (("CANCELLED" ("CANCELLED" . t))
              ("WAITING" ("WAITING" . t))
              ;; ("OFF" ("OFF" . t)) ; 2023-07-07 disable
              ("HOLD" ("WAITING") ("HOLD" . t))
              (done ("WAITING") ("HOLD"))
              ("TODO" ("WAITING") ("CANCELLED") ("HOLD")) ; ("OFF")
              ("NEXT" ("WAITING") ("CANCELLED") ("HOLD")) ; ("OFF")
              ("DONE" ("WAITING") ("CANCELLED") ("HOLD")) ; ("OFF")
              )))

;;;; Adding New Tasks Quickly with 'org-capture-templates'

;; Capture templates for: TODO tasks, Notes, appointments, phone calls, meetings, and org-protocol

(setq org-capture-templates
      (quote
       (
        ;; ("t" "todo" entry (file "~/sync/org/workflow/inbox.org")
        ;;  "* TODO %?\n%U\n%a\n" :clock-in t :clock-resume t)
        ;; ("s" "slipbox" entry (file "~/sync/org/workflow/inbox.org")
        ;;  "* %? :NOTE:\n%U\n%a\n" :clock-in t :clock-resume t)
        ;; ("s" "Memo on Slipbox" entry (file+olp "~/sync/org/workflow/inbox.org" "Slipbox")
        ;;  "* %u %? " :prepend t) ; 타임스템프
        ;; ("l" "Link on Slipbox" entry (file+headline "~/sync/org/workflow/inbox.org" "Slipbox")
        ;;  "* %a %^g\n %?\n %T\n %i")

        ;; ("f" "Fleeting note" entry  (file "~/sync/org/workflow/inbox.org")
        ;;  "* TODO %^{Note title}\nContext: %U\n%a\n%?" :empty-lines-before 1 )

        ("f" "Fleeting note (/w Clock)" entry (file+headline "~/sync/org/workflow/inbox.org" "Slipbox")
         "* TODO %^{Note title}\nContext: %U\n%a\n%?" :clock-in t :clock-resume t)
        ;; "* %?\n%U\n%a\n" :clock-in t :clock-resume t)

        ;; ("p" "org-protocol" entry (file "~/sync/org/workflow/inbox.org")
        ;;  "* TODO Review %c\n%U\n" :immediate-finish t)
        ;; ("m" "meeting" entry (file "~/sync/org/workflow/inbox.org")
        ;;  "* MEETING with %? :MEETING:\n%U" :clock-in t :clock-resume t)
        ;; ("p" "phone call" entry (file "~/sync/org/workflow/inbox.org")
        ;;  "* PHONE %? :PHONE:\n%U" :clock-in t :clock-resume t)
        ;; ("r" "respond" entry (file "~/sync/org/workflow/inbox.org")
        ;;  "* NEXT Respond to %:from on %:subject\nSCHEDULED: %t\n%U\n%a\n" :clock-in t :clock-resume t :immediate-finish t)

        ;; habit
        ;; ("h" "habit" entry (file "~/sync/org/workflow/inbox.org")
        ;;  "* NEXT %?\n%U\n%a\nSCHEDULED: %(format-time-string \"%<<%Y-%m-%d %a .+1d/3d>>\")\n:PROPERTIES:\n:STYLE: habit\n:REPEAT_TO_STATE: NEXT\n:END:\n")

        ;; 22/11/21--10:43 :: add for awk org-drill
        ;; ("A" "Awk drill question" entry
        ;;  (file+headline "~/sync/org/git/learn-awk/awk.org" "Drills")
        ;;  "\n\n** %^{Question title}                           :awk:drill:\n\n   %^{Question body} \n\n*** Answer \n\n    #+BEGIN_SRC awk :results output code :in-file ./text-files/%^{text file}\n      %^{awk program}\n    #+END_SRC")
        )
       )
      )
;; 이런 디테일이 중요하더라. 지저분하게 만들지 않도록 하는 팁들.
;; Remove empty LOGBOOK drawers on clock out
(defun bh/remove-empty-drawer-on-clock-out ()
  (interactive)
  (save-excursion
    (beginning-of-line 0)
    (org-remove-empty-drawer-at "LOGBOOK" (point))))
;;    (org-remove-empty-drawer-at (point))))

(add-hook 'org-clock-out-hook 'bh/remove-empty-drawer-on-clock-out 'append)

;;;; Refiling Tasks

(setq org-refile-targets (quote ((nil :maxlevel . 1)
                                 (org-agenda-files :maxlevel . 1))))
;; org-refile-targets '((nil :maxlevel . 4)
;;                      (org-agenda-files :maxlevel . 3))

;; Use full outline paths for refile targets - we file directly with IDO
;; (setq org-refile-use-outline-path (quote file))
;; (setq org-refile-use-outline-path t) ; default nil

;; Save Org buffers after refiling!
;; 리파일 후 저장하도록 해야 싱크 문제가 안생긴다.
(advice-add 'org-refile :after 'org-save-all-org-buffers)

(setq org-outline-path-complete-in-steps nil) ; default t

;; Allow refile to create parent tasks with confirmation
(setq org-refile-allow-creating-parent-nodes (quote confirm))

;; Exclude DONE state tasks from refile targets
;; (defun bh/verify-refile-target ()
;;   "Exclude todo keywords with a done state from refile targets"
;;   (not (member (nth 2 (org-heading-components)) org-done-keywords)))
;; (setq org-refile-target-verify-function 'bh/verify-refile-target)

(global-set-key (kbd "C-c R") 'org-refile-hydra/body)

(defun fk/org-refile-fixed-location (file headline)
  "Refile headline without selecting from refile-targets."
  (let ((pos (save-window-excursion
               (find-file file)
               (org-find-exact-headline-in-buffer headline))))
    (org-refile nil nil (list headline file nil pos))))

(defun fk/org-refile-fixed-location-with-closed-timestamp (file headline)
  "Refile headline without selecting from refile-targets. Add
      \"CLOSED\" timestamp info."
  (add-hook 'org-after-refile-insert-hook (lambda () (org-add-planning-info 'closed (org-current-effective-time))) -100)
  (fk/org-refile-fixed-location file headline)
  (remove-hook 'org-after-refile-insert-hook (lambda () (org-add-planning-info 'closed (org-current-effective-time)))))

(defun fk/org-refile-done ()
  (interactive)
  (fk/org-refile-fixed-location-with-closed-timestamp "archive.org" "Done"))

(defun fk/org-refile-trash ()
  (interactive)
  (fk/org-refile-fixed-location-with-closed-timestamp "archive.org" "Trash"))
(defhydra org-refile-hydra
  (:color red :hint nil)
  "
  ^Move^                 ^Todo^             ^IAM^            ^Archive^
  ----------------------------------------------------------------------
  _n_: Next              _p_: Project     _E_: Emacs         _d_: Done
  _p_: Previous          _e_: Emacs       _P_: Presentation  _x_: Trash
  ^^                     _w_: Work        _T_: Tech          _s_: Schedule
  _1_: Low Priority      _h_: Personal    _H_: Home          ^^
  _2_: Medium Priority   _f_: Family      _W_: Watch         ^^
  _3_: High Priority     ^^               _R_: Read          ^^
  ^^                     ^^               _O_: Other         ^^
  _c_: Set Time Effort   ^^                                  ^^
  _a_: Set Tags          ^^                                  ^^


  "
  ;; Move
  ("n" next-line)
  ("p" previous-line)
  ("1" (lambda () (interactive) (org-priority ?C)))
  ("2" (lambda () (interactive) (org-priority ?B)))
  ("3" (lambda () (interactive) (org-priority ?A)))
  ("c" org-set-effort)
  ("a" org-set-tags-command)
  ;; Todo
  ("p" (lambda () (interactive) (fk/org-refile-fixed-location "project.org" "TODOS")))
  ("e" (lambda () (interactive) (fk/org-refile-fixed-location "Emacs.org" "TODOS")))
  ("w" (lambda () (interactive) (fk/org-refile-fixed-location "Junghanacs.org" "TODOS")))
  ("h" (lambda () (interactive) (fk/org-refile-fixed-location "personal.org" "TODOS")))
  ("f" (lambda () (interactive) (fk/org-refile-fixed-location "family.org" "TODOS")))
  ;; IAM
  ("E" (lambda () (interactive) (fk/org-refile-fixed-location "IAM.org" "Emacs")))
  ("P" (lambda () (interactive) (fk/org-refile-fixed-location "IAM.org" "Presentation")))
  ("T" (lambda () (interactive) (fk/org-refile-fixed-location "IAM.org" "Tech")))
  ("H" (lambda () (interactive) (fk/org-refile-fixed-location "IAM.org" "Home")))
  ("W" (lambda () (interactive) (fk/org-refile-fixed-location "IAM.org" "Watch")))
  ("R" (lambda () (interactive) (fk/org-refile-fixed-location "IAM.org" "Read")))
  ("O" (lambda () (interactive) (fk/org-refile-fixed-location "IAM.org" "Other")))
  ;; Archive
  ("d" fk/org-refile-done)
  ("x" fk/org-refile-trash)
  ("s" (lambda () (interactive) (fk/org-refile-fixed-location "archive.org" "Schedule")))
  ;; General
  ("M" org-refile "Refile manually")
  ("S" save-buffer "Save buffer")
  ("q" nil "Quit" :color blue))

;;;; Custom Agenda Views

Custom agenda views are used for:
- Single block agenda shows the following
  + overview of today
  + Finding tasks to be refiled
  + Finding stuck projects
  + Finding NEXT tasks to work on
  + Show all related tasks
  + Reviewing projects
  + Finding tasks waiting on something
  + Findings tasks to be archived
- Finding notes
- Viewing habits

;; ex) 2022-09-19 (월)
(setq org-agenda-format-date "%Y-%m-%d (%a)")

;; Do not dim blocked tasks
(setq org-agenda-dim-blocked-tasks nil)

;; Compact the block agenda view
;; t :: block saparator turns off
(setq org-agenda-compact-blocks nil)

(advice-add 'org-agenda-exit :after #'org-save-all-org-buffers)

;; Custom agenda command definitions
(setq org-agenda-custom-commands
      (quote (("N" "Notes" tags "NOTE"
               ((org-agenda-overriding-header "Notes")
                (org-tags-match-list-sublevels t)))
              ("h" "Habits" tags-todo "STYLE=\"habit\""
               ((org-agenda-overriding-header "Habits")
                (org-agenda-sorting-strategy
                 '(todo-state-down effort-up category-keep))))
              ;; Review JH
              ("r" "Agenda review"
               ((agenda "" ((org-agenda-span 7)))
                (stuck "")
                (todo "NEXT")
                (todo "TODO")
                (todo "HOLD"))
               ((org-agenda-archives-mode t)
                (org-agenda-compact-blocks nil)
                (org-agenda-show-all-dates nil)))
              (" " "Agenda"
               ((agenda "" nil)
                (tags "INBOX"
                      ((org-agenda-overriding-header "Inbox - Tasks to Refile")
                       (org-tags-match-list-sublevels nil)))
                (tags-todo "-CANCELLED/!"
                           ((org-agenda-overriding-header "Stuck Projects")
                            (org-agenda-skip-function 'bh/skip-non-stuck-projects)
                            (org-agenda-sorting-strategy
                             '(category-keep))))
                (tags-todo "-HOLD-CANCELLED/!"
                           ((org-agenda-overriding-header "Projects")
                            (org-agenda-skip-function 'bh/skip-non-projects)
                            (org-tags-match-list-sublevels 'indented)
                            (org-agenda-sorting-strategy
                             '(category-keep))))
                (tags-todo "-CANCELLED/!NEXT"
                           ((org-agenda-overriding-header (concat "Project Next Tasks"
                                                                  (if bh/hide-scheduled-and-waiting-next-tasks
                                                                      ""
                                                                    " (including WAITING and SCHEDULED tasks)")))
                            (org-agenda-skip-function 'bh/skip-projects-and-habits-and-single-tasks)
                            (org-tags-match-list-sublevels t)
                            (org-agenda-todo-ignore-scheduled bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-todo-ignore-deadlines bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-todo-ignore-with-date bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-sorting-strategy
                             '(todo-state-down effort-up category-keep))))
                (tags-todo "-INBOX-CANCELLED-WAITING-HOLD/!"
                           ((org-agenda-overriding-header (concat "Project Subtasks"
                                                                  (if bh/hide-scheduled-and-waiting-next-tasks
                                                                      ""
                                                                    " (including WAITING and SCHEDULED tasks)")))
                            (org-agenda-skip-function 'bh/skip-non-project-tasks)
                            (org-agenda-todo-ignore-scheduled bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-todo-ignore-deadlines bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-todo-ignore-with-date bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-sorting-strategy
                             '(category-keep))))
                (tags-todo "-INBOX-CANCELLED-WAITING-HOLD/!"
                           ((org-agenda-overriding-header (concat "Standalone Tasks"
                                                                  (if bh/hide-scheduled-and-waiting-next-tasks
                                                                      ""
                                                                    " (including WAITING and SCHEDULED tasks)")))
                            (org-agenda-skip-function 'bh/skip-project-tasks)
                            (org-agenda-todo-ignore-scheduled bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-todo-ignore-deadlines bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-todo-ignore-with-date bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-sorting-strategy
                             '(category-keep))))
                (tags-todo "-CANCELLED+WAITING|HOLD/!"
                           ((org-agenda-overriding-header (concat "Waiting and Postponed Tasks"
                                                                  (if bh/hide-scheduled-and-waiting-next-tasks
                                                                      ""
                                                                    " (including WAITING and SCHEDULED tasks)")))
                            (org-agenda-skip-function 'bh/skip-non-tasks)
                            (org-tags-match-list-sublevels nil)
                            (org-agenda-todo-ignore-scheduled bh/hide-scheduled-and-waiting-next-tasks)
                            (org-agenda-todo-ignore-deadlines bh/hide-scheduled-and-waiting-next-tasks)))
                (tags "-INBOX/DONE"
                      ((org-agenda-overriding-header "Tasks to Archive")
                       (org-agenda-skip-function 'bh/skip-non-archivable-tasks)
                       (org-tags-match-list-sublevels nil))))
               nil))))

(defun bh/org-auto-exclude-function (tag)
  "Automatic task exclusion in the agenda with / RET"
  (and (cond
        ((string= tag "hold")
         t)
        ((string= tag "farm")
         t))
       (concat "-" tag)))
(setq org-agenda-auto-exclude-function 'bh/org-auto-exclude-function)

My day goes generally like this:

- Punch in (this starts the clock on the default task)
- Look at the agenda and make a mental note of anything important to deal with today
- Read email and news
  - create notes, and tasks for things that need responses with org-capture
- Check refile tasks and respond to emails
- Look at my agenda and work on important tasks for today
  - Clock it in
  - Work on it until it is =DONE= or it gets interrupted
- Work on tasks
- Make journal entries (=C-c c j=) for interruptions
- Punch out for lunch and punch back in after lunch
- work on more tasks
- Refile tasks to empty the list
  - Tag tasks to be refiled with =m= collecting all tasks for the same target
  - Bulk refile the tasks to the target location with =B r=
  - Repeat (or refile individually with =C-c C-w=) until all refile tasks are gone
- Mark habits done today as DONE
- Punch out at the end of the work day

;;;; Time Clocking

* TODO Project A
** NEXT TASK 1
** TODO TASK 2
** TODO TASK 3
* Tasks
** TODO Some miscellaneous task

Default Task
[d] norang          Organization                          <-- Task B
The task interrupted by starting the last one
[i] norang          Organization                          <-- Task B
Current Clocking Task
[c] org             NEXT Document my use of org-mode      <-- Task A
Recent Tasks
[1] org             NEXT Document my use of org-mode      <-- Task A
[2] norang          Organization                          <-- Task B
...
[Z] org             DONE Fix default section links        <-- 35 clock task entries ago

(setq org-agenda-clock-consistency-checks
      (quote (:max-duration "4:00"
                            :min-duration 0
                            :max-gap 0
                            :gap-ok-around ("4:00"))))

(setq org-clock-idle-time 30) ; 10

(setq org-clock-reminder-timer (run-with-timer
                                t (* org-clock-idle-time 20) ; 60
                                (lambda ()
                                  (unless (org-clocking-p)
                                    (alert "Do you forget to clock-in?"
                                           :title "Org Clock")))))

;; Resume clocking task when emacs is restarted
(org-clock-persistence-insinuate)
(org-clock-auto-clockout-insinuate) ; auto-clockout

;; Show lot of clocking history so it's easy to pick items off the C-F11 list
(setq org-clock-history-length 10) ;;
;; Resume clocking task on clock-in if the clock is open
(setq org-clock-in-resume t)
;; Separate drawers for clocking and logs
(setq org-drawers (quote ("PROPERTIES" "LOGBOOK")))
;; Save clock data and state changes and notes in the LOGBOOK drawer
(setq org-clock-into-drawer t)
;; Sometimes I change tasks I'm clocking quickly - this removes clocked tasks with 0:00 duration
(setq org-clock-out-remove-zero-time-clocks t)
;; Clock out when moving task to a done state
(setq org-clock-out-when-done t)
;; Save the running clock and all clock history when exiting Emacs, load it on startup
(setq org-clock-persist t)
;; Enable auto clock resolution for finding open clocks
(setq org-clock-auto-clock-resolution (quote when-no-clock-is-running))
;; Include current clocking task in clock reports
(setq org-clock-report-include-clocking-task t)

;; org-clock-persist for share with machines
(setq org-clock-persist-query-save t)
(setq org-clock-persist-query-resume t)

(setq bh/keep-clock-running nil)

(defun bh/clock-in-to-next (kw)
  "Switch a task from TODO to NEXT when clocking in.
  Skips capture tasks, projects, and subprojects.
  Switch projects and subprojects from NEXT back to TODO"
  (when (not (and (boundp 'org-capture-mode) org-capture-mode))
    (cond
     ((and (member (org-get-todo-state) (list "TODO"))
           (bh/is-task-p))
      "NEXT")
     ((and (member (org-get-todo-state) (list "NEXT"))
           (bh/is-project-p))
      "TODO"))))

;; Change tasks to NEXT when clocking in
(setq org-clock-in-switch-to-state 'bh/clock-in-to-next)

(defun bh/find-project-task ()
  "Move point to the parent (project) task if any"
  (save-restriction
    (widen)
    (let ((parent-task (save-excursion (org-back-to-heading 'invisible-ok) (point))))
      (while (org-up-heading-safe)
        (when (member (nth 2 (org-heading-components)) org-todo-keywords-1)
          (setq parent-task (point))))
      (goto-char parent-task)
      parent-task)))

(defun bh/punch-in (arg)
  "Start continuous clocking and set the default task to the
  selected task.  If no task is selected set the Organization task
  as the default task."
  (interactive "p")
  (setq bh/keep-clock-running t)
  (if (equal major-mode 'org-agenda-mode)
      ;; We're in the agenda
      (let* ((marker (org-get-at-bol 'org-hd-marker))
             (tags (org-with-point-at marker (org-get-tags-at))))
        (if (and (eq arg 4) tags)
            (org-agenda-clock-in '(16))
          (bh/clock-in-organization-task-as-default)))
    ;; We are not in the agenda
    (save-restriction
      (widen)
      ;; Find the tags on the current task
      (if (and (equal major-mode 'org-mode) (not (org-before-first-heading-p)) (eq arg 4))
          (org-clock-in '(16))
        (bh/clock-in-organization-task-as-default)))))

(defun bh/punch-out ()
  (interactive)
  (setq bh/keep-clock-running nil)
  (when (org-clock-is-active)
    (org-clock-out))
  (org-agenda-remove-restriction-lock))

(defun bh/clock-in-default-task ()
  (save-excursion
    (org-with-point-at org-clock-default-task
      (org-clock-in))))

(defun bh/clock-in-parent-task ()
  "Move point to the parent (project) task if any and clock in"
  (let ((parent-task))
    (save-excursion
      (save-restriction
        (widen)
        (while (and (not parent-task) (org-up-heading-safe))
          (when (member (nth 2 (org-heading-components)) org-todo-keywords-1)
            (setq parent-task (point))))
        (if parent-task
            (org-with-point-at parent-task
              (org-clock-in))
          (when bh/keep-clock-running
            (bh/clock-in-default-task)))))))

(defvar bh/organization-task-id "eb155a82-92b2-4f25-a3c6-0304591af2f9")

(defun bh/clock-in-organization-task-as-default ()
  (interactive)
  (org-with-point-at (org-id-find bh/organization-task-id 'marker)
    (org-clock-in '(16))))

(defun bh/clock-out-maybe ()
  (when (and bh/keep-clock-running
             (not org-clock-clocking-in)
             (marker-buffer org-clock-default-task)
             (not org-clock-resolving-clocks-due-to-idleness))
    (bh/clock-in-parent-task)))

(add-hook 'org-clock-out-hook 'bh/clock-out-maybe 'append)

;; (require 'org-id) ; delete compile error on emacs-29
(defun bh/clock-in-task-by-id (id)
  "Clock in a task by id"
  (org-with-point-at (org-id-find id 'marker)
    (org-clock-in nil)))

(defun bh/clock-in-last-task (arg)
  "Clock in the interrupted task if there is one
  Skip the default task and get the next one.
  A prefix arg forces clock in of the default task."
  (interactive "p")
  (let ((clock-in-to-task
         (cond
          ((eq arg 4) org-clock-default-task)
          ((and (org-clock-is-active)
                (equal org-clock-default-task (cadr org-clock-history)))
           (caddr org-clock-history))
          ((org-clock-is-active) (cadr org-clock-history))
          ((equal org-clock-default-task (car org-clock-history)) (cadr org-clock-history))
          (t (car org-clock-history)))))
    (widen)
    (org-with-point-at clock-in-to-task
      (org-clock-in nil))))

(setq org-time-stamp-rounding-minutes (quote (1 1)))

(setq org-agenda-clock-consistency-checks
      (quote (:max-duration "4:00"
                            :min-duration 0
                            :max-gap 0
                            :gap-ok-around ("4:00"))))

;;;; Time Reporting and Tracking

;; Sometimes I change tasks I'm clocking quickly
;;  - this removes clocked tasks with 0:00 duration
(setq org-clock-out-remove-zero-time-clocks t)

;; Agenda clock report parameters
(setq org-agenda-clockreport-parameter-plist
      (quote (:link t :maxlevel 5 :fileskip0 t :compact t :narrow 80)))

;; from DW
;; (setq org-columns-default-format
;;      "%20CATEGORY(Category) %65ITEM(Task) %TODO %6Effort(Estim){:} %6CLOCKSUM(Clock) %TAGS")

;; from org-mode-crate
;; (setq org-columns-default-format
;;      "%50ITEM(Task) %5Effort(Effort){:} %5CLOCKSUM %3PRIORITY %20DEADLINE %20SCHEDULED %2  0TIMESTAMP %TODO %CATEGORY(Category) %TAGS")

;; Set default column view headings: Task Effort Clock_Summary
(setq org-columns-default-format "%80ITEM(Task) %10Effort(Effort){:} %10CLOCKSUM")

;; global Effort estimate values
;; global STYLE property values for completion
(setq org-global-properties
      (quote
       (("Effort_ALL" . "0:15 0:30 0:45 1:00 2:00 3:00 4:00 5:00 6:00 8:00")
        ("STYLE_ALL" . "habit"))))

;; Agenda log mode items to display (closed clock : default)
;; 이전 이맥스는 state가 기본이었다. 지금은 시간 기준으로 표기한다.
;; closed    Show entries that have been closed on that day.
;; clock     Show entries that have received clocked time on that day.
;; state     Show all logged state changes.
(setq org-agenda-log-mode-items '(closed clock state))
(setq org-agenda-log-mode-add-notes nil)

;; sort 관련 기능을 확인해보고 정의한 함수들이 필요 없으면 빼면 된다.
(setq org-agenda-sort-notime-is-late t) ; Org 9.4
(setq org-agenda-sort-noeffort-is-high t) ; Org 9.4

Original Estimate
#+BEGIN: columnview :hlines 1 :id local
| Task                        | Estimated Effort | CLOCKSUM |
|-----------------------------+------------------+----------|
| ** TODO Project to estimate |             5:40 |          |
| *** TODO Step 1             |             0:10 |          |
| *** TODO Step 2             |             0:10 |          |
| *** TODO Step 3             |             5:10 |          |
| **** TODO Step 3.1          |             2:00 |          |
| **** TODO Step 3.2          |             3:00 |          |
| **** TODO Step 3.3          |             0:10 |          |
| *** TODO Step 4             |             0:10 |          |
#+END:

1) 글로벌 cloumnview
| Task                           | Effort | CLOCKSUM |
|--------------------------------+--------+----------|
| Programming Clojure Reviews    |        |          |
|--------------------------------+--------+----------|
| Sample                         |   3:30 |          |
| SP: Sample Project to estimate |   3:30 |          |
| SP: Step 1                     |   1:00 |          |
| SP: Step 2                     |   0:30 |          |
| SP: Step 3                     |   1:30 |          |
| SP: Step 3.1                   |   0:30 |          |
| SP: Step 3.2                   |   0:30 |          |
| SP: Step 3.3                   |   0:30 |          |
| SP: Step 4                     |   0:30 |          |

2) 로컬 cloumnview
| Task                           | Effort | CLOCKSUM |
|--------------------------------+--------+----------|
| SP: Sample Project to estimate |   3:30 |          |
| SP: Step 1                     |   1:00 |          |
| SP: Step 2                     |   0:30 |          |
| SP: Step 3                     |   1:30 |          |
| SP: Step 3.1                   |   0:30 |          |
| SP: Step 3.2                   |   0:30 |          |
| SP: Step 3.3                   |   0:30 |          |
| SP: Step 4                     |   0:30 |          |

3) clocktable
| Headline     | Time   |
|--------------+--------|
| *Total time* | *0:00* |

;; current  Only the time in the current instance of the clock
;; today    All time clocked into this task today
;; repeat   All time clocked into this task since last repeat
;; all      All time ever recorded for this task
;; auto     Automatically, either all, or repeat for repeating tasks
(setq org-clock-mode-line-entry t)
(setq org-clock-mode-line-line-total 'auto)

;;;; Tags and Categories

;; FILETAGS로 상속받은 태그는 어젠다에서 숨긴다. 상속 태그
;; (setq org-agenda-show-inherited-tags nil)

(setq org-auto-align-tags nil) ; default t
;; 태그 위치를 좌측으로 당겨야 버티컬 창 여러개에서 한 줄로 표현할 수 있다.
(setq org-tags-column 0) ; default -77

;; Allow setting single tags without the menu
;; (setq org-fast-tag-selection-single-key (quote expert))
;; (setq org-fast-tag-selection-single-key nil)
(setq org-fast-tag-selection-single-key t)

(setq org-tags-match-list-sublevels 'intented) ; t
(setq org-tags-exclude-from-inheritance '("Project")) ; nil

;; Tags with fast selection keys
(setq org-tag-alist (quote ((:startgroup)
                            ("@errand" . ?e)
                            ("@office" . ?o)
                            ("@home" . ?h)
                            ("@farm" . ?f) ; Example
                            (:endgroup)
                            ("HOLD" . ?h)
                            ("Project" . ?p) ; Project
                            ("NOTE" . ?n)
                            ("CANCELLED" . ?c)
                            ("FLAGGED" . ??))))

;; For tag searches ignore tasks with scheduled and deadline dates
(setq org-agenda-tags-todo-honor-ignore-options t)

;;;; Handling Notes

;;;; Handling Phone Calls and Contacts

;; (require 'bbdb)
;; (require 'bbdb-com)

;; ;; bbdb.db 파일
;; (setq bbdb-file "~/sync/org/bbdb.db")

;; 아래 코드는 최신 내용으로 넣어야 겠다. 캡처랑 연동하도록.

;; (global-set-key (kbd "<f9> p") 'bh/phone-call)
;; Phone capture template handling with BBDB lookup
;; Adapted from code by Gregory J. Grubbs
;; (defun bh/phone-call ()
;;   "Return name and company info for caller from bbdb lookup"
;;   (interactive)
;;   (let* (name rec caller)
;;     (setq name (completing-read "Who is calling? "
;;                                 (bbdb-hashtable)
;;                                 'bbdb-completion-predicate
;;                                 'confirm))
;;     (when (> (length name) 0)
;;       ;; Something was supplied - look it up in bbdb
;;       (setq rec
;;             (or (first
;;                  (or (bbdb-search (bbdb-records) name nil nil)
;;                      (bbdb-search (bbdb-records) nil name nil)))
;;                 name)))

;;     ;; Build the bbdb link if we have a bbdb record, otherwise just return the name
;;     (setq caller (cond ((and rec (vectorp rec))
;;                         (let ((name (bbdb-record-name rec))
;;                               (company (bbdb-record-company rec)))
;;                           (concat "[[bbdb:"
;;                                   name "]["
;;                                   name "]]"
;;                                   (when company
;;                                     (concat " - " company)))))
;;                        (rec)
;;                        (t "NameOfCaller")))
;;     (insert caller)))

;;;; GTD

(setq org-agenda-span 'day)

;; /home/junghan/.emacs.tshu/lisp/lang-org.el
;; 노랑님은 이걸 사용하지 않고 직접 서브 시스템을 만들었다.
(setq org-stuck-projects (quote ("" nil nil "")))

(defun bh/is-project-p ()
  "Any task with a todo keyword subtask"
  (save-restriction
    (widen)
    (let ((has-subtask)
          (subtree-end (save-excursion (org-end-of-subtree t)))
          (is-a-task (member (nth 2 (org-heading-components)) org-todo-keywords-1)))
      (save-excursion
        (forward-line 1)
        (while (and (not has-subtask)
                    (< (point) subtree-end)
                    (re-search-forward "^\*+ " subtree-end t))
          (when (member (org-get-todo-state) org-todo-keywords-1)
            (setq has-subtask t))))
      (and is-a-task has-subtask))))

(defun bh/is-project-subtree-p ()
  "Any task with a todo keyword that is in a project subtree.
  Callers of this function already widen the buffer view."
  (let ((task (save-excursion (org-back-to-heading 'invisible-ok)
                              (point))))
    (save-excursion
      (bh/find-project-task)
      (if (equal (point) task)
          nil
        t))))

(defun bh/is-task-p ()
  "Any task with a todo keyword and no subtask"
  (save-restriction
    (widen)
    (let ((has-subtask)
          (subtree-end (save-excursion (org-end-of-subtree t)))
          (is-a-task (member (nth 2 (org-heading-components)) org-todo-keywords-1)))
      (save-excursion
        (forward-line 1)
        (while (and (not has-subtask)
                    (< (point) subtree-end)
                    (re-search-forward "^\*+ " subtree-end t))
          (when (member (org-get-todo-state) org-todo-keywords-1)
            (setq has-subtask t))))
      (and is-a-task (not has-subtask)))))

(defun bh/is-subproject-p ()
  "Any task which is a subtask of another project"
  (let ((is-subproject)
        (is-a-task (member (nth 2 (org-heading-components)) org-todo-keywords-1)))
    (save-excursion
      (while (and (not is-subproject) (org-up-heading-safe))
        (when (member (nth 2 (org-heading-components)) org-todo-keywords-1)
          (setq is-subproject t))))
    (and is-a-task is-subproject)))

(defun bh/list-sublevels-for-projects-indented ()
  "Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
    This is normally used by skipping functions where this variable is already local to the agenda."
  (if (marker-buffer org-agenda-restrict-begin)
      (setq org-tags-match-list-sublevels 'indented)
    (setq org-tags-match-list-sublevels nil))
  nil)

(defun bh/list-sublevels-for-projects ()
  "Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
    This is normally used by skipping functions where this variable is already local to the agenda."
  (if (marker-buffer org-agenda-restrict-begin)
      (setq org-tags-match-list-sublevels t)
    (setq org-tags-match-list-sublevels nil))
  nil)

(defvar bh/hide-scheduled-and-waiting-next-tasks t)

(defun bh/toggle-next-task-display ()
  (interactive)
  (setq bh/hide-scheduled-and-waiting-next-tasks (not bh/hide-scheduled-and-waiting-next-tasks))
  (when  (equal major-mode 'org-agenda-mode)
    (org-agenda-redo))
  (message "%s WAITING and SCHEDULED NEXT Tasks" (if bh/hide-scheduled-and-waiting-next-tasks "Hide" "Show")))

(defun bh/skip-stuck-projects ()
  "Skip trees that are not stuck projects"
  (save-restriction
    (widen)
    (let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
      (if (bh/is-project-p)
          (let* ((subtree-end (save-excursion (org-end-of-subtree t)))
                 (has-next ))
            (save-excursion
              (forward-line 1)
              (while (and (not has-next) (< (point) subtree-end) (re-search-forward "^\\*+ NEXT " subtree-end t))
                (unless (member "WAITING" (org-get-tags-at))
                  (setq has-next t))))
            (if has-next
                nil
              next-headline)) ; a stuck project, has subtasks but no next task
        nil))))

(defun bh/skip-non-stuck-projects ()
  "Skip trees that are not stuck projects"
  ;; (bh/list-sublevels-for-projects-indented)
  (save-restriction
    (widen)
    (let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
      (if (bh/is-project-p)
          (let* ((subtree-end (save-excursion (org-end-of-subtree t)))
                 (has-next ))
            (save-excursion
              (forward-line 1)
              (while (and (not has-next) (< (point) subtree-end) (re-search-forward "^\\*+ NEXT " subtree-end t))
                (unless (member "WAITING" (org-get-tags-at))
                  (setq has-next t))))
            (if has-next
                next-headline
              nil)) ; a stuck project, has subtasks but no next task
        next-headline))))

(defun bh/skip-non-projects ()
  "Skip trees that are not projects"
  ;; (bh/list-sublevels-for-projects-indented)
  (if (save-excursion (bh/skip-non-stuck-projects))
      (save-restriction
        (widen)
        (let ((subtree-end (save-excursion (org-end-of-subtree t))))
          (cond
           ((bh/is-project-p)
            nil)
           ((and (bh/is-project-subtree-p) (not (bh/is-task-p)))
            nil)
           (t
            subtree-end))))
    (save-excursion (org-end-of-subtree t))))

(defun bh/skip-non-tasks ()
  "Show non-project tasks.
Skip project and sub-project tasks, habits, and project related tasks."
  (save-restriction
    (widen)
    (let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
      (cond
       ((bh/is-task-p)
        nil)
       (t
        next-headline)))))

(defun bh/skip-project-trees-and-habits ()
  "Skip trees that are projects"
  (save-restriction
    (widen)
    (let ((subtree-end (save-excursion (org-end-of-subtree t))))
      (cond
       ((bh/is-project-p)
        subtree-end)
       ((org-is-habit-p)
        subtree-end)
       (t
        nil)))))

(defun bh/skip-projects-and-habits-and-single-tasks ()
  "Skip trees that are projects, tasks that are habits, single non-project tasks"
  (save-restriction
    (widen)
    (let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
      (cond
       ((org-is-habit-p)
        next-headline)
       ((and bh/hide-scheduled-and-waiting-next-tasks
             (member "WAITING" (org-get-tags-at)))
        next-headline)
       ((bh/is-project-p)
        next-headline)
       ((and (bh/is-task-p) (not (bh/is-project-subtree-p)))
        next-headline)
       (t
        nil)))))

(defun bh/skip-project-tasks-maybe ()
  "Show tasks related to the current restriction.
  When restricted to a project, skip project and sub project tasks, habits, NEXT tasks, and loose tasks.
  When not restricted, skip project and sub-project tasks, habits, and project related tasks."
  (save-restriction
    (widen)
    (let* ((subtree-end (save-excursion (org-end-of-subtree t)))
           (next-headline (save-excursion (or (outline-next-heading) (point-max))))
           (limit-to-project (marker-buffer org-agenda-restrict-begin)))
      (cond
       ((bh/is-project-p)
        next-headline)
       ((org-is-habit-p)
        subtree-end)
       ((and (not limit-to-project)
             (bh/is-project-subtree-p))
        subtree-end)
       ((and limit-to-project
             (bh/is-project-subtree-p)
             (member (org-get-todo-state) (list "NEXT")))
        subtree-end)
       (t
        nil)))))

(defun bh/skip-project-tasks ()
  "Show non-project tasks.
  Skip project and sub-project tasks, habits, and project related tasks."
  (save-restriction
    (widen)
    (let* ((subtree-end (save-excursion (org-end-of-subtree t))))
      (cond
       ((bh/is-project-p)
        subtree-end)
       ((org-is-habit-p)
        subtree-end)
       ((bh/is-project-subtree-p)
        subtree-end)
       (t
        nil)))))

(defun bh/skip-non-project-tasks ()
  "Show project tasks.
  Skip project and sub-project tasks, habits, and loose non-project tasks."
  (save-restriction
    (widen)
    (let* ((subtree-end (save-excursion (org-end-of-subtree t)))
           (next-headline (save-excursion (or (outline-next-heading) (point-max)))))
      (cond
       ((bh/is-project-p)
        next-headline)
       ((org-is-habit-p)
        subtree-end)
       ((and (bh/is-project-subtree-p)
             (member (org-get-todo-state) (list "NEXT")))
        subtree-end)
       ((not (bh/is-project-subtree-p))
        subtree-end)
       (t
        nil)))))

(defun bh/skip-projects-and-habits ()
  "Skip trees that are projects and tasks that are habits"
  (save-restriction
    (widen)
    (let ((subtree-end (save-excursion (org-end-of-subtree t))))
      (cond
       ((bh/is-project-p)
        subtree-end)
       ((org-is-habit-p)
        subtree-end)
       (t
        nil)))))

(defun bh/skip-non-subprojects ()
  "Skip trees that are not projects"
  (let ((next-headline (save-excursion (outline-next-heading))))
    (if (bh/is-subproject-p)
        nil
      next-headline)))

;;;; Publishing and Exporting

(require 'ob-clojure)
;; (require 'cider)
(defcustom org-babel-clojure-backend nil
  "Backend used to evaluate Clojure code blocks."
  :group 'org-babel
  :type '(choice
          (const :tag "inf-clojure" inf-clojure)
          (const :tag "cider" cider)
          (const :tag "slime" slime)
          (const :tag "bb" bb)
          (const :tag "Not configured yet" nil)))

(defun elisp->clj (in)
  (cond
   ((listp in) (concat "[" (s-join " " (mapcar #'elisp->clj in)) "]"))
   (t (format "%s" in))))

(defun ob-clojure-eval-with-bb (expanded params)
  "Evaluate EXPANDED code block with PARAMS using babashka."
  (unless (executable-find "bb")
    (user-error "Babashka not installed"))
  (let* ((stdin (let ((stdin (cdr (assq :stdin params))))
                  (when stdin
                    (elisp->clj
                     (org-babel-ref-resolve stdin)))))
         (input (cdr (assq :input params)))
         (file (make-temp-file "ob-clojure-bb" nil nil expanded))
         (command (concat (when stdin (format "echo %s | " (shell-quote-argument stdin)))
                          (format "bb %s -f %s"
                                  (cond
                                   ((equal input "edn") "")
                                   ((equal input "text") "-i")
                                   (t ""))
                                  (shell-quote-argument file))))
         (result (shell-command-to-string command)))
    (s-trim result)))

(defun org-babel-execute:clojure (body params)
  "Execute a block of Clojure code with Babel."
  (unless org-babel-clojure-backend
    (user-error "You need to customize org-babel-clojure-backend"))
  (let* ((expanded (org-babel-expand-body:clojure body params))
         (result-params (cdr (assq :result-params params)))
         result)
    (setq result
          (cond
           ((eq org-babel-clojure-backend 'inf-clojure)
            (ob-clojure-eval-with-inf-clojure expanded params))
           ((eq org-babel-clojure-backend 'cider)
            (ob-clojure-eval-with-cider expanded params))
           ((eq org-babel-clojure-backend 'slime)
            (ob-clojure-eval-with-slime expanded params))
           ((eq org-babel-clojure-backend 'bb)
            (ob-clojure-eval-with-bb expanded params))))
    (org-babel-result-cond result-params
      result
      (condition-case nil (org-babel-script-escape result)
        (error result)))))

;; bb
(customize-set-variable 'org-babel-clojure-backend 'bb)

(add-hook 'org-mode-hook (lambda () (require 'ob-clojure)))

(add-hook 'org-babel-after-execute-hook 'bh/display-inline-images 'append)

;; 대문자가 좋다 uppercase better
;; (setq org-babel-uppercase-example-markers t) ; default nil

(defun bh/display-inline-images ()
  (condition-case nil
      (org-display-inline-images)
    (error nil)))

(setq org-startup-with-inline-images nil)
(setq org-image-actual-width (min (/ (display-pixel-width) 3) 640))
;; (setq org-image-actual-width 400)

(setq plantuml-jar-path "/usr/share/plantuml/plantuml.jar"
      org-plantuml-jar-path "/usr/share/plantuml/plantuml.jar")
(setq org-ditaa-jar-path "/usr/share/ditaa/ditaa.jar")

(org-babel-do-load-languages
 (quote org-babel-load-languages)
 (quote ((emacs-lisp . t)
         (shell . t)
         (awk . t)
         (ditaa . t)
         (sed . t)
         (python . t)
         (gnuplot . t)
         (clojure . t)
         (ruby . t)
         (js . t)
         (ledger . t)
         (org . t)
         (plantuml . t)
         (mermaid . t)
         (d2 . t)
         )))

(setq org-src-fontify-natively t)

;; I prefer C-c C-c over C-c ' (more consistent)
(define-key org-src-mode-map (kbd "C-c C-c") #'org-edit-src-exit)