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 ")")(or (thing-at-point 'list t) (concat (thing-at-point 'sexp t) ")"))))
              (book "")
              (chapter "")
              (verse-num "")
              (line-bounds nil)
              (multiple nil)
              (Bible (concat emacs-sheath Bible-Directory (elt Bibles (- (read-number (concat (format "Choose a Bible: %s" Bibles) " Bible Number ")) 1)))))
          (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-abbrev (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 (concat emacs-sheath Bible-Directory (elt Bibles (- (read-number (concat (format "Choose a Bible: %s" Bibles) " Bible Number ")) 1)))))
      (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-abbrev (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)
          (Bible (concat emacs-sheath Bible-Directory (elt Bibles (- (read-number (concat (format "Choose a Bible: %s" Bibles) " Bible Number ")) 1)))))
      (if (get-buffer "Word Search")
          (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))
          (message (buffer-file-name))
          (goto-char (point-min))
          (while (re-search-forward word nil t)
            (save-excursion
              (message "search")
              (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)))
              (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))))))
        (if (equal verse "")
            (insert "No Verses Found.")))))

(defun emacs-sword-word-search-immediately (word)
  (interactive "sWhich word to search? ")
  (let ((verse "")
        (chapter "")
        (book "")
        (pointer 1)
        (buff (buffer-name))
        (Bible (concat emacs-sheath Bible-Directory (elt Bibles (- (read-number (concat (format "Choose a Bible: %s" Bibles) " Bible Number ")) 1)))))
    (message Bible)
    (display-buffer (current-buffer))
    (insert (concat "\n:WordSearch:\n# Search String: '" word "'"))
    (with-current-buffer  (or (get-file-buffer Bible)
                              (find-file-noselect Bible))
      (message (buffer-file-name))
      (goto-char (point-min))
      (while (re-search-forward word nil t)
        (save-excursion
          (message "search")
          (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))))
        (with-current-buffer buff
          (message "print")
          (insert (concat "\n" (progn (if (equal book (progn
                                                        (save-excursion
                                                          (org-up-heading-safe)
                                                          (thing-at-point 'line t)))) "" (s-replace-regexp "\\** \\([ -z]*\\)" "- \\1 ::" book)))))
          (insert (concat (progn (if (equal chapter (progn
                                                      (save-excursion
                                                        (org-back-to-heading)
                                                        (thing-at-point 'line t)))) "" (s-replace-regexp "\\** \\([ -z]*\\)" " - \\1 ::" chapter)))
                          "    " verse "    [[file:" Bible "::" pointer "][go to verse]]"))
          (delete-duplicate-lines (point-at-bol -4) (point)))))
    (insert "\n:end:")
    (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-sheath Audio-Directory "*-\"" (string-trim-right book) "\"/")))) 0 -1))
      (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 player " " output))
      (start-process-shell-command "emacs-sword-audio" nil (concat player " " output )))))

(defun emacs-sword--check-abbrev (book)
  "checks if book is an abbreviation, if so, expands book to full length."
  (message book)
  (if (eq (length book) 3)
      (progn
        (message "Expanding book abbreviation...")
        (setq book (cdr (assoc book Abbreviations)))
        (message "done")
        (message book))
    (progn
      (message "book not an abbeviation.  Moving on...")
      (message book))))

(defun emacs-sword-visit-abbrev ()
  "lists all abbreviations and what they abbreviate in an alist"
  (interactive)
  (if (get-buffer "abbrev list")
          (kill-buffer "abbrev list"))
  (get-buffer-create "abbrev list")
  (with-current-buffer "abbrev list"
    (display-buffer (current-buffer))
    (insert (format "%s" Abbreviations))
    (goto-char (point-min))
    (while (re-search-forward ")" nil t)
      (replace-match ")\n"))))

  (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-sheath Hebrew)) ((string= (match-string 0) "g") (concat emacs-sheath Greek))))
        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))
      (display-buffer (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 (concat emacs-sheath Resource-Directory (elt Resources (- (read-number (concat (format "Choose a Resource: %s" Resources) " Resource Number ")) 1)))))
    (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-resources ()
  (interactive)
  (dired (concat emacs-sheath Resource-Directory)))
(defun emacs-sword-visit-dictionaries ()
  (interactive)
  (dired (concat emacs-sheath Dictionary-Directory)))
(defun emacs-sword-visit-bibles ()
  (interactive)
  (dired (concat emacs-sheath Bible-Directory)))

(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 Resource-Repository: ")
  (message url)
  (if (> (length url) 1)
      (with-temp-buffer
        (setq-local def-dir default-directory
                    default-directory (concat emacs-sheath Resource-Directory))
        (shell-command (concat "wget '" url "'") t)
        (shell-command "unzip *.zip" t))
    (progn
      (eww 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-sheath 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-sheath 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-sheath 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-sheath)
      (message "Files found")
    (with-temp-buffer
      ;(make-directory emacs-sheath)
      ;(setq-local def-dir default-directory
        ;         default-directory emacs-sheath)
      (shell-command "wget https://malanderengineering.com/packages/repo/emacs-sword.zip" t)
      (shell-command "unzip emacs-sword.zip" t)
      (shell-command (concat "mv emacs-sword" emacs-sheath) t)
      (shell-command "rm emacs-sword.zip" t))))

  (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 prepare-kjv+ ()
    (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-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-sheath Bible-Directory "KJV+.org")))
        (with-current-buffer (or (get-file-buffer Bible)
                                 (find-file-noselect Bible))
          (replace-regexp "file:.+?strong" (concat "file:" emacs-sheath Dictionary-Directory "strong")))))

(if (require 'treemacs nil 'noerror)
(defun emacs-sword--treemacs-sword ()
  (if (string-search emacs-sheath (format "%s" (treemacs-workspaces)))
      (message "workspace exists...")
    (with-temp-buffer (treemacs-edit-workspaces)
                      (goto-char (point-max))
                      (insert (concat "* Emacs Sword\n** Emacs-Sword\n- path :: " emacs-sheath))
                      (treemacs-finish-edit)))))
(emacs-sword--treemacs-sword)

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