emacs-sword

(defun emacs-sword-find-verse ()
  "This function finds the verse reference in the previous list (eg. (John  3:16)), and pastes it in a source block.  the syntax is (BOOKssCHAPTER:VERSE) where BOOK the the book, s is space, CHAPTER is chapter, and VERSE is verse.
The command to run this function is C-S-b f (or Ctrl-Shift-b f) or you could call it with M-x emacs-sword-find-verse (where M is Alt)."
  (interactive)

  (let ((output "")
    (verse (save-excursion
         (search-backward ")")
         (let ((line (thing-at-point 'line t)))
           (with-temp-buffer
             (insert line)
             (search-backward ")")(or (thing-at-point 'list t) (concat (thing-at-point 'sexp t) ")"))
             )
           )
         )
           )
    (book "")
    (chapter "")
    (verse-num "")
    (line-bounds nil)
    (multiple nil)
    (Bible (emacs-sword--query-user 'bible)))
    (message "Let #1")
    (with-current-buffer (or (get-file-buffer Bible)
                             (find-file-noselect Bible))
      (message "Change Buffer to %s" Bible)
      (save-excursion
    (message "move point")
    (goto-char (point-min))
    (get-buffer-create "kjv-search")
    (with-current-buffer "kjv-search"
          (message "Change Buffer to kjv-search")
          (goto-char (point-min))
          (insert verse)
          (goto-char (point-min))
      (message "Reference inserted in temp buffer")
          (let ((search-result (search-forward "-" nil t)))
            (if search-result
        (progn
          (save-excursion
            (message "go to end?")
            (let ((rest (search-forward ">" nil t)))
              (if rest
              (setq multiple ">")
            (progn
              (message "%s" (number-at-point))
              (setq multiple (number-at-point))
              (message "%d" multiple)
              (message "%d" multiple))))))))
          (goto-char (point-min))
          (setq book (progn (re-search-forward "[1-3]?[A-z]+\\s-?[0-9]?") (match-string 0))
        chapter (progn (goto-char (point-min)) (re-search-forward "[0-9]+:" nil t) (substring (match-string 0) 0 -1))
        verse-num (progn (goto-char (point-min)) (re-search-forward ":[0-9]*" nil t) (substring (match-string 0) 1)))
      (setq book (emacs-sword--check-book (string-trim-right book)))
      (message "set all search params")
      (message "multiple == %s" multiple)
          (kill-current-buffer))
    (search-forward (string-trim-right (concat "** " book)) nil t)
    (message "book: %s" book)
    (search-forward (concat "Chapter " chapter) nil t)
    (message "chapter: %s" chapter)
    (search-forward (concat "(" verse-num ")") nil t)
    (message "verse: %s" verse-num)
    (message "%s" (point))
    (message "%s" (current-buffer))
    (setq output "\n")
    (if multiple
        (progn
          (if (equal multiple ">")
          (save-excursion
            (message "Checking Chapter Length")
            (or (search-forward "*** Chapter" nil t) (goto-char (point-max)))
            (re-search-backward "[0-9]\)" nil t)
            (goto-char (+ 1 (point)))
            (message "%s" (number-at-point))
            (setq multiple (- (number-at-point) (number-at-point) (number-at-point)))
            (message "multiple == %d" multiple)))
          
          (progn
        (dotimes (count (+ (- (string-to-number (concat "-" verse-num)) multiple) 0))
          (setq output (concat output (thing-at-point 'line t))) (forward-line 1) (message output) (message "%d" count)))
              (setq output (concat output (thing-at-point 'line t))))
      (setq output (concat output (thing-at-point 'line t))))))
    
    
    (save-excursion
      (progn(search-backward ")")
            (beginning-of-line)
            (thing-at-point 'list)
            (search-forward ")")
            (kill-line 0)
            (insert (concat "#+NAME: " (string-trim-right book) " " chapter ":" verse-num (if multiple (format "%s" multiple)) "\n#+begin_verse "))
            (insert output)
        (insert "#+end_verse")
            (unless multiple
              (progn (re-search-backward "([0-9]") (setq line-bounds (point)) (search-forward ")"))
              (delete-region line-bounds (point)))
            (message "pasted %s" verse))))
      )
  
  

  (defun emacs-sword-link-verse ()
    "This function finds a verse in the previous array (eg. [John  3:16]) and make a link to it in your Bible of choice. the syntax is [BOOKssCHAPTER:VERSE] where BOOK the the book, s is space, CHAPTER is chapter, and VERSE is verse.
The command to run this function is C-S-b l b (or Ctrl-Shift-b l b) or you could call it with M-x emacs-sword-link-verse (where M is Alt)."
    (interactive)
    (let ((output "")
          (verse (save-excursion
                   (search-backward "]")(search-forward "]")(thing-at-point 'sexp t)))
          (book "")
          (chapter "")
          (verse-num "")
          (Bible (emacs-sword--query-user 'bible)))
      (message "Let #1")
      (with-current-buffer (or (get-file-buffer Bible)
                               (find-file-noselect Bible))
        (message "Change Buffer to %s" Bible)
        (save-excursion
          (message "move point")
          (goto-char (point-min))
          (get-buffer-create "kjv-search")
          (with-current-buffer "kjv-search"
            (message "Change Buffer to kjv-search")
            (goto-char (point-min))
            (insert verse)
            (goto-char (point-min))
            (setq book (progn (re-search-forward "[A-z]+\\s-?[0-9]?") (substring (match-string 0) 1))
                  chapter (progn (goto-char (point-min)) (re-search-forward "[0-9]+:") (substring (match-string 0) 0 -1)) 
                  verse-num (progn (goto-char (point-min)) (re-search-forward ":[0-9]*") (substring (match-string 0) 1)))
        (setq book (emacs-sword--check-book (string-trim-right book)))
            (message "set all search params")
            (kill-current-buffer))
          (search-forward (string-trim-right (concat "** " book)))
          (message "book: %s" book)
          (search-forward (concat "Chapter " chapter))
          (message "chapter: %s" chapter)
          (search-forward (concat "(" verse-num ")"))
          (message "verse: %s" verse-num)
          (message "%s" (point))
          (message "%s" (current-buffer))
          (setq output (concat "[[file:" Bible "::" (number-to-string (line-number-at-pos)) "]" verse "]" ))
          ))
      (save-excursion
        (let ((bound1 nil)
              (bound2 nil))
          (search-backward "[")
          (setq bound1 (point))
          (thing-at-point 'sexp)
          (search-forward "]")
          (setq bound2 (point))
          (delete-region bound1 bound2)
          (insert output)))))
  

  (defun emacs-sword-word-search (word)
    "This function searches the Bible of choice for WORD, where word is your word of choice, and prints all verses where WORD is found in a buffer.
The command to run this function is C-S-b s (or Ctrl-Shift-b s) or you could call it with M-x emacs-sword-word-search (where M is Alt)."
    (interactive "sWhich word to search? ")
    (let ((verse "")
          (chapter "")
          (book "")
          (pointer 1)
      (word-list (emacs-sword--search-criteria-breakdown word))
          (Bible (emacs-sword--query-user 'bible)))
      (emacs-sword--word-search-backend verse chapter book pointer word-list Bible) ; run the backend
      (view-buffer-other-window (get-buffer "Word Search")) ; bring the word search buffer to the fore
      ;; We dont need to do anything else, as the backed automatically puts everything in a temp buffer
      ))

(defun emacs-sword-word-search-immediately (word)
  "Similar to emacs-sword-word-search, except it puts the result in a drawer in a list format (as opposed to header)

Almost fully anotated, if you want to see an example of what to do with emacs-sword--word-search-backend programmatically"
  (interactive "sWhich word to search? ")
  (let ((verse "")
        (chapter "")
        (last-chapter "")
        (book "")
        (last-book "")
        (pointer 1)
    (word-list (emacs-sword--search-criteria-breakdown word))
    (buff (buffer-name))
        (Bible (emacs-sword--query-user 'bible)))
    (message Bible)
    (emacs-sword--word-search-backend verse chapter book pointer word-list Bible) ; run the backend
    ;; Now, we need to export from the temp buffer to the current buffer
    (insert (concat "\n:WordSearch:\n# Search String: '" word "'")) ; insert drawer header
    (with-current-buffer  "Word Search" ; go to the search buffer emacs-sword--word-search-backend generates
      (goto-char (point-min)) ; make sure we are at the start (we should be, but just in case)
      (while (re-search-forward "([0-9]+)" nil t) ;; while there are still lines
        (save-excursion
          (message "search")
          (setq verse (thing-at-point 'line t) ; verse is the current line
                pointer (save-excursion (search-forward ".org::") (number-to-string (thing-at-point 'number))) ; pointer is the pointer in the link
                chapter (progn (re-search-backward "***\sChapter") (thing-at-point 'line t)) ; chapter is the last "*** Chapter" instance
                book (progn (org-up-heading-safe) (thing-at-point 'line t)))) ; Book, see org-up-heading-safe for how it works
    (with-current-buffer buff ; Back to the users buffer
      (message "print")
      (insert (concat "\n" (progn (if (equal book last-book) (progn (setq last-chapter "") "") (replace-regexp-in-string "\\** \\([ -z]*\\)" "- \\1 ::" book))))) ; convert the book heading into the list format
      (insert (concat (progn (if (equal chapter last-chapter) "" (replace-regexp-in-string "\\** \\([ -z]*\\)" " - \\1 ::" chapter))) ; convert the chapter to list format
              "    " verse "    [[file:" Bible "::" pointer "][go to verse]]")) ; insert verse and link
      (delete-duplicate-lines (point-at-bol -4) (point)) ; delete the duplicated lines in the past 5 lines
      (setq last-book book  ; set last-book and last-chapter to current book and chapter
        last-chapter chapter))))
    (insert "\n:end:")
    (if (equal verse "")
    (insert "No Verses Found."))))

(defun emacs-sword--word-search-backend (verse chapter book pointer word-list Bible)
  "Backend of word search so both word search and word search immediately can stay up to date"
  
  (if (get-buffer "Word Search")  ; Kill the Word Search buffer if it is open.  Essentially clean up
      (kill-buffer "Word Search"))
  (get-buffer-create "Word Search")
  (with-current-buffer "Word Search"
    (org-mode)
    (insert (concat "# Search String: '" word "'"))
    (message Bible)
    ;;(display-buffer (current-buffer))
    (with-current-buffer  (or (get-file-buffer Bible)
                              (find-file-noselect Bible))

      ;; In the days of yore, this was required to get emacs to search properly
      ;; in word mode.  Not really sure I know why it was, I must have forgotten.
      ;; Either way, it does not seem to be nessicary now, and was causing warnings.
      ;(fundamental-mode)
      (save-excursion
      (message (buffer-file-name))
      (goto-char (point-min))
      (search-forward "* ")
      (while (re-search-forward (car word-list) nil t)
        (save-excursion
          (message "search")
      ;; This line has word-list[0]
      (message (thing-at-point 'line t))
          (setq verse (thing-at-point 'line t)
                pointer (number-to-string (line-number-at-pos))
                chapter (progn (re-search-backward "***\sChapter") (thing-at-point 'line t))
                book (progn (org-up-heading-safe) (thing-at-point 'line t)))
      
      ;; Check if the other words are in the verse
      (setq has-others nil) ; initialise has-others
      (setq others-not-available "no")
      
      (dolist (item word-list) ; for item in word-list
        (if (string-match-p item verse) ; if item (as a regexp) in verse
        (setq has-others t)
          (setq has-others nil
            others-not-available "yes")
          ))
      
      (if (and has-others (equal others-not-available "no")) ; if verse has others and not one of the others is not available
          (progn ;; if yes, then continue as planned
        (message "Verse has all word")
        (with-current-buffer "Word Search"
                  (message "print")
                  (insert (concat "\n" (progn (if (equal book (progn
                                (save-excursion
                                  (org-up-heading-safe)
                                  (thing-at-point 'line t)))) "" book))))
                  (insert (concat (progn (if (equal chapter (progn
                                  (save-excursion
                                (org-back-to-heading)
                                (thing-at-point 'line t)))) "" chapter))
                  verse "[[file:" Bible "::" pointer "][go to verse]]"))
                  (delete-duplicate-lines (point-at-bol -4) (point)))
        )
        (progn ;; else, skip this word
          (message "Verse does not have all words, skipping")
          )
        )
      
          )))

      ;(org-mode)
      )
    (goto-char (point-min))
    (if (equal verse "")
    (insert "No Verses Found.")))
  
  )

(defun emacs-sword-play-audio ()
  "This is a function for playing audio
 To use, press C-S-b a after a list with the format of (BOOKssCHAPTER) where BOOK is the book you want, s is space, and CHAPTER is the chapter you want to start on."
  (interactive)
  (let ((output "")
        (verse (save-excursion
                 (search-backward ")")(or (thing-at-point 'list) (concat (thing-at-point 'sexp) ")"))))
        (book "")
        (chapter "")
    (multiple ""))
    (message "Let #1")
    (with-temp-buffer
      (message "Change Buffer to search")
      (goto-char (point-min))
      (insert verse)
      (goto-char (point-min))
      (message "Reference inserted in temp buffer")
      (setq book (progn (re-search-forward "[0-9]?\\s-?[A-z]+\\s-?[0-9]?") (match-string 0))
            chapter (progn  (re-search-forward "[0-9]+") (match-string 0))
        multiple (if (equal ?- (following-char)) ">")
        default-directory (substring (shell-command-to-string (concat "/bin/echo " (expand-file-name (concat emacs-sword-sheath emacs-sword-audio-directory "*-\"" (string-trim-right book) "\"/")))) 0 -1))
      (setq book (emacs-sword--check-book (string-trim-right book)))
      (message "set all search params")
      (message multiple)
      (message default-directory)
      (setq output (concat "\"" book (if (equal (length chapter) 1) "0") chapter ".mp3\""))
      (if (equal multiple ">")
      (progn
        (message "multiple")
        (setq chapter (number-to-string (+ 1 (string-to-number chapter))))
        (message chapter)
        (while (file-exists-p (concat "" book (if (equal (length chapter) 1) "0") chapter ".mp3"))
        (setq output (concat output  " "  (concat "\"" book (if (equal (length chapter) 1) "0") chapter ".mp3\""))
          chapter (number-to-string (+ 1 (string-to-number chapter))))
        (message output))))
      (message (concat emacs-sword-player " " output))
      (start-process-shell-command "emacs-sword-audio" nil (concat emacs-sword-player " " output )))))

(defun emacs-sword--check-book (book)
  "checks if book is an abbreviation, if so, expands book to full length."
  (message book)
  (setq book (emacs-sword--captialize-abbrev book))
  (if (eq (length book) 3)
      (progn
    (message "Expanding book abbreviation...")
    (setq book (cdr (assoc book emacs-sword-abbreviations)))
    (message "done")
    (message book))
    (progn
      (message "book not an abbreviation in 'emacs-sword-abbreviations. Checking Levenshtein...")
      (emacs-sword--check-book-levenshtein book)
      )))

(defun emacs-sword--captialize-abbrev (input)
  "Capitalise the input as an abbreviation
This actually captializes the second character if the first is non-capitalizable"
  (let ((old (downcase input))
    (new (downcase input)))
    (setq new (concat (upcase (substring new 0 1)) (substring new 1)))
    (if (eq 0 (string-match-p "[0-9]" (substring new 0 1)))
    (setq new (concat (substring new 0 1) (capitalize (substring new 1)))))
    (message new)
    )
  )

(defun emacs-sword-visit-abbrev ()
  "Lists all abbreviations and what they abbreviate in an alist."
  (declare (obsolete "please use the built in function (describe-variable). Will be removed by v3.5 or v4.0, whichever is soonest" "3.0.0"))
  (interactive)
  (describe-variable 'emacs-sword-abbreviations))

(defun emacs-sword--check-book-levenshtein (book)
  "checks if a book is within a certain levenshtein distance (with transpositions) of any book name"
  (message book)
  (let ((cost 100)
    (last-cost)
    (true-book))
    (progn
      (dolist (element emacs-sword-abbreviations true-book)
    (setq last-cost cost)
    (setq cost (min cost (levenshtein-distance (upcase (cdr element)) (upcase book))) )
    (if (not (equal last-cost cost))
        (setq true-book (cdr element))
      )
    )
      )
    )
  )

(defun emacs-sword--query-user (for-what)
  "Query the user for which `for-what' (which is a symbol) to use.
Valid valued are: `bible', `dicationary', and `resource'"
  (let ((directory (symbol-value (intern-soft (concat "emacs-sword-" (symbol-name for-what) "-directory"))))
        (list (symbol-value (intern-soft (concat "emacs-sword-" (symbol-name for-what) "-list")))))
    (concat
     emacs-sword-sheath
     directory
     (elt list
          (-
           (read-number
            (concat (format "Choose a %s: %s" (capitalize (symbol-name for-what)) list) " " (capitalize (symbol-name for-what)) " Number ")
            )
           1)
          )
     )))

  (defun emacs-sword-goto-def ()
    "This function finds a Strong's Number in the previous list (eg. (g1)) and opens it in another window.  The syntax is (DN) where D is h or g (h for hebrew and g for greek), and N is number
The command to run this function is C-S-b g (or Ctrl-Shift-b g) or you could call it with M-x emacs-sword-goto-def (where M is Alt)."
    (interactive)
    (let ((dictionary "")
          (id "")
          (command (save-excursion
                       (search-backward ")") (thing-at-point 'list t))))
      (get-buffer-create "kjv-search")
      (with-current-buffer "kjv-search"
        (message "Change Buffer to kjv-search")
        (goto-char (point-min))
        (insert command)
        (goto-char (point-min))
    (message "set dictionary...")
        (setq dictionary (progn (re-search-forward "h\\|g") (cond ((string= (match-string 0) "h") (concat emacs-sword-sheath emacs-sword-dictionary-directory emacs-sword-hebrew-dictionary)) ((string= (match-string 0) "g") (concat emacs-sword-sheath emacs-sword-dictionary-directory emacs-sword-greek-dictionary))))
        id (progn (goto-char (point-min)) (re-search-forward "[0-9]+") (concat "(" (match-string 0) ")")))
      (message "set all search params")
      (kill-current-buffer))
      (message "%s" dictionary)
      (message "%s" id)
      (set-buffer (or (get-file-buffer dictionary)
                      (find-file-noselect dictionary)))
      (goto-char (point-min))
      (search-forward (concat "** " id))
      (view-buffer-other-window (current-buffer))
      (message "done")))

(defun emacs-sword-link-resource (desc)
  "This function is for linking a resource. The syntax is [REFERNECE] where REFERENCE is the header (sans *s) you want to link.
You can run this function with C-S-b l r."
  (interactive "sWhat is the link decription?(default: [Reference]) ")
  (let ((output "")
        (resource (save-excursion
                    (search-backward "]")(search-forward "]")(thing-at-point 'sexp t)))
        (chapter "")
        (book (emacs-sword--query-user 'resource)))
    (message "Let #1")
    (with-current-buffer (or (get-file-buffer book)
                             (find-file-noselect book))
      (message "Change Buffer to %s" book)
      (save-excursion
        (message "move point")
        (goto-char (point-min))
        (get-buffer-create "search")
        (with-current-buffer "search"
          (message "Change Buffer to search")
          (goto-char (point-min))
          (insert resource)
          (goto-char (point-min))
          (setq chapter (progn (goto-char (point-min)) (re-search-forward "\\[.+") (substring (match-string 0) 1 -1)))
          (message "set all search params")
      (if desc 
          (setq desc chapter))
      (message desc)
          (kill-current-buffer))
    (re-search-forward (concat "\\*+\s" chapter))
        (message "chapter: %s" chapter)
        (message "%s" (point))
        (message "%s" (current-buffer))
        (setq output (concat "[[file:" book "::" (number-to-string (line-number-at-pos)) "][" desc "]]" ))
        ))
    (save-excursion
      (let ((bound1 nil)
            (bound2 nil))
        (search-backward "[")
        (setq bound1 (point))
        (thing-at-point 'sexp)
        (search-forward "]")
        (setq bound2 (point))
        (delete-region bound1 bound2)
        (insert output)))))

(defun emacs-sword-visit-bibles ()
  "Query user for which Bible to visit, then open it in view-mode."
  (interactive)
  (let ((bible (emacs-sword--query-user 'bible)))
    (view-file bible)))
(defun emacs-sword-visit-dictionaries ()
  "Query user for which dictionary to visit, then open it in view-mode."
  (interactive)
  (let ((dict (emacs-sword--query-user 'dictionary)))
    (view-file dict)))

;; Begin Legacy Visit Functions
(defun emacs-sword-visit-resources ()
  "Open `emacs-sword-resource-directory' in `dired'.

While this function uses the legacy visit definition, it works best for resources that may not be in the `emacs-sword-resource-list', as they are (for example) images or something."
  (interactive)
  (dired (concat emacs-sword-sheath emacs-sword-resource-directory)))
(defun emacs-sword-visit-dictionaries-legacy ()
  "Open `emacs-sword-dictionary-directory' in `dired'"
  (interactive)
  (dired (concat emacs-sword-sheath emacs-sword-dictionary-directory)))
(defun emacs-sword-visit-bibles-legacy ()
  "Open `emacs-sword-bible-directory' in `dired'"
  (interactive)
  (dired (concat emacs-sword-sheath emacs-sword-bible-directory)))
;; End Legacy Visit Functions

(defun emacs-sword-resource-downloader (url)
  (interactive "sPlease enter the url of the resource you want to download. if blank, you can see the resources at emacs-sword-resource-repository: ")
  (message url)
  (if (> (length url) 1)
      (with-temp-buffer
    (setq-local def-dir default-directory
            default-directory (concat emacs-sword-sheath emacs-sword-resource-directory))
    (shell-command (concat "wget '" url "'") t)
    (shell-command "unzip *.zip" t))
    (progn
      (eww emacs-sword-resource-repository)
      (switch-to-buffer "*eww*")
      (local-set-key (kbd "d") 'emacs-sword--download)
      (local-set-key (kbd "q") 'emacs-sword--kill-eww))))
(defun emacs-sword--kill-eww ()
  (interactive)
  (local-set-key (kbd "d") 'eww-download)
  (kill-buffer "*eww*")
  (with-temp-buffer
    (setq-local def-dir default-directory
        default-directory (concat emacs-sword-sheath emacs-sword-resource-directory))
    (shell-command  "unzip *.zip" t)
    (shell-command "rm *.zip" t)))

(defun emacs-sword--download ()
  "simple fork of `eww-download'.
Use link at point if there is one, else the current page's URL."
  (interactive)
  (access-file (concat emacs-sword-sheath emacs-sword-resource-directory) "Download failed")
  (let ((url (or (get-text-property (point) 'shr-url)
                 (eww-current-url))))
    (if (not url)
        (message "No URL under point")
      (url-retrieve url 'emacs-sword--download-callback (list url)))))
(defun emacs-sword--download-callback (status url)
  (unless (plist-get status :error)
    (let* ((obj (url-generic-parse-url url))
           (path (directory-file-name (car (url-path-and-query obj))))
           (file (eww-make-unique-file-name
                  (eww-decode-url-file-name (file-name-nondirectory path))
                  (concat emacs-sword-sheath emacs-sword-resource-directory))))
      (goto-char (point-min))
      (re-search-forward "\r?\n\r?\n")
      (let ((coding-system-for-write 'no-conversion))
        (write-region (point) (point-max) file))
      (message "Saved %s" file))))

(defun emacs-sword-init ()
  (if (file-directory-p emacs-sword-sheath)
      (message "Emacs Sword already initialized.")
    (with-temp-buffer
      (message "Emacs Sword is not initialized.  Downloading default resources...")
      (shell-command "wget https://malanderengineering.com/packages/repo/emacs-sword.zip" t)
      (shell-command (concat "unzip emacs-sword.zip -d " emacs-sword-sheath) t)
      (shell-command "rm emacs-sword.zip" t))))
(emacs-sword-init)

  (defun emacs-sword-customize ()
    "This function opens the emacs-sword customization.
The command to run this function is C-S-b c (or Ctrl-Shift-b c) or you could call it with M-x emacs-sword-customize (where M is Alt)."
    (interactive)
    (customize-group-other-window 'emacs-sword))

  (defun emacs-sword-prepare-kjv+ ()
    "Convert kjv+ from Xiphos extract format to proper org-mode format"
    (interactive)
    (let ((id 1)
          (place (point)))
      (save-excursion
        (query-replace-regexp "(1)" "*** Chapter \n(1)")
        )
      (save-excursion
        (while (search-forward "*** Chapter" nil t)
          (insert (concat " " (number-to-string id)))
          (setq id (+ id 1))))
      (save-excursion
        (query-replace-regexp "H\\([0-9]+\\)" "[[file:strongshebrew.org::*(\\1)][\\1]]"))))


(defun emacs-sword-prepare-bible ()
  "Insert org-mode headers for each chapter"
    (interactive)
    (let ((id 1)
          (place (point)))
      (save-excursion
        (query-replace-regexp "(1)" "*** Chapter \n(1)")
        )
      (save-excursion
        (while (search-forward "*** Chapter" nil t)
          (insert (concat " " (number-to-string id)))
          (setq id (+ id 1))))))

    (defun emacs-sword-reload-KJV+-numbers ()
      "This function corrects the links in KJV+.  whenever you change your emacs-sword custom variables is it a good idea to run this command.
The command to run this function is C-S-b r r (or Ctrl-Shift-b r r) or you could call it with M-x emacs-sword-reload-KJV+-numbers (where M is Alt)."
      (interactive)
      (let ((Bible (concat emacs-sword-sheath emacs-sword-bible-directory "KJV+.org")))
        (with-current-buffer (or (get-file-buffer Bible)
                                 (find-file-noselect Bible))
          (replace-regexp "file:.+?strong" (concat "file:" emacs-sword-sheath emacs-sword-dictionary-directory "strong")))))

(if emacs-sword-enable-treemacs
    (progn
      (require 'treemacs)
      (treemacs)
      (treemacs)
      (setq emacs-sword-treemacs-work (expand-file-name (substring emacs-sword-sheath 0 -1)))
      (defun emacs-sword--treemacs-sword ()
        (if (string-search emacs-sword-treemacs-work (format "%s" (treemacs-workspaces)))
            (message "workspace exists...")
          (with-temp-buffer
            (split-window-below)
            (treemacs-edit-workspaces)
            (goto-char (point-max))
            (insert (concat "* Emacs Sword\n** Emacs-Sword\n- path :: " emacs-sword-treemacs-work))
            (treemacs-finish-edit))))
      (emacs-sword--treemacs-sword)
      (defun emacs-sword-treemacs ()
        (interactive)
        (treemacs-do-switch-workspace "Emacs Sword")
        (treemacs))))

(defun emacs-sword-treemacs ()
  (interactive)
  (treemacs-do-switch-workspace "Emacs Sword")
  (treemacs))