;;; spine.el — personal reading tracker, served from Emacs

;; --- package bootstrap ------------------------------------------------

(require 'package)
(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/")
             t)
(package-initialize)

(dolist (pkg '(simple-httpd mustache ht))
  (unless (package-installed-p pkg)
    (package-refresh-contents)
    (package-install pkg)))

(require 'simple-httpd)
(require 'mustache)
(require 'ht)
(require 'cl-lib)

;; --- configuration ----------------------------------------------------

(defvar spine-port 8080
  "Port for the Spine HTTP server.")
(defvar spine-host nil
  "Host for the Spine HTTP server.
nil means localhost only. Set to a string like \"0.0.0.0\" to listen on
all interfaces.")

(defvar spine-org-file "~/spine/books.org"
  "Path to the spine.org data file.")

(defvar spine-template-dir
  (expand-file-name "templates/"
                    (file-name-directory load-file-name))
  "Directory containing .mustache templates.")

;; --- template rendering -----------------------------------------------

(defun spine-render (name context)
  "Render templates/NAME.mustache with CONTEXT (an ht hash table).
Returns the rendered string."
  (mustache-render
   (with-temp-buffer
     (insert-file-contents
      (expand-file-name name spine-template-dir))
     (buffer-string))
   context))

(defun spine--h (text)
  "HTML-escape TEXT."
  (when text
    (let ((s text))
      (setq s (replace-regexp-in-string "&" "&" s))
      (setq s (replace-regexp-in-string "<" "&lt;" s))
      (setq s (replace-regexp-in-string ">" "&gt;" s))
      (setq s (replace-regexp-in-string "\"" "&quot;" s))
      s)))

(defun spine--extract-notes (hl-begin hl-end)
  "Extract reading notes from headline body between HL-BEGIN and HL-END.
Returns list of (date-string text-string) pairs."
  (let ((notes nil))
    (save-excursion
      (goto-char hl-begin)
      ;; Skip past PROPERTIES and LOGBOOK drawers
      (while (re-search-forward
              "^[ \t]*:\\(PROPERTIES\\|LOGBOOK\\):" hl-end t)
        (re-search-forward "^[ \t]*:END:" hl-end t))
      ;; Collect note lines: "- [YYYY-MM-DD] text"
      (while (re-search-forward
              "^- \\[\\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\}\\)\\] \\(.*\\)"
              hl-end t)
        (push (list (match-string 1) (match-string 2)) notes)))
    (nreverse notes)))


(defun spine--prop (pos prop)
  "Get Org property PROP at headline position POS.
Returns nil for empty or missing properties."
  (let ((val (save-excursion
               (goto-char pos)
               (org-entry-get nil prop))))
    (and val (> (length val) 0) val)))
(defun spine-books ()
  "Return a list of plists, one per top-level headline in `spine-org-file'.
Returns nil if the file is missing or cannot be parsed."
  (if (not (file-exists-p spine-org-file))
      (progn
        (message "spine-books: file not found: %s" spine-org-file)
        nil)
    (condition-case err
        (with-temp-buffer
          (insert-file-contents spine-org-file)
          (org-mode)
          (let ((books nil))
            (org-element-map (org-element-parse-buffer 'headline) 'headline
              (lambda (hl)
                (when (= (org-element-property :level hl) 1)
                  (let ((pos (org-element-property :begin hl)))
                    (push (list :id       (spine--prop pos "ID")
                                :title    (org-element-property :title hl)
                                :status   (org-element-property :todo-keyword hl)
                                :author   (spine--prop pos "AUTHOR")
                                :isbn     (spine--prop pos "ISBN")
                                :cover    (spine--prop pos "COVER")
                                :format   (spine--prop pos "FORMAT")
                                :rec_by   (spine--prop pos "REC_BY")
                                :rec_note (spine--prop pos "REC_NOTE")
                                :rating   (spine--prop pos "RATING")
                                :added    (spine--prop pos "ADDED")
                                :tags     (org-element-property :tags hl)
                                :notes    (spine--extract-notes
                                           (org-element-property :begin hl)
                                           (org-element-property :end hl)))
                          books)))))
            (nreverse books)))
      (error
       (message "spine-books: failed to parse %s: %s"
                spine-org-file (error-message-string err))
       nil))))

(defun spine-render-index (books &optional selected-id)
  "Render the index page HTML for BOOKS, expanding the book matching SELECTED-ID."
  (let ((order '("WANT" "READING" "READ" "ABANDONED"))
        (grouped (make-hash-table :test 'equal))
        (total 0)
        (reading-count 0))
    ;; Count totals
    (dolist (book books)
      (cl-incf total)
      (when (equal "READING" (plist-get book :status))
        (cl-incf reading-count)))
    ;; Group books by status
    (dolist (book books)
      (let* ((status (or (plist-get book :status) "WANT")))
        (push book (gethash status grouped))))
    ;; Render
    (with-temp-buffer
      (insert "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n")
      (insert "<meta charset=\"utf-8\">\n")
      (insert "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n")
      (insert "<title>Spine</title>\n")
      (insert "<link rel=\"stylesheet\""
              " href=\"https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css\">\n")
      (insert "<style>\n")
      (insert ".spine-row{display:flex;align-items:center;gap:0.75rem;")
      (insert "padding:0.4rem 0;border-bottom:1px solid var(--pico-muted-border-color)}\n")
      (insert ".spine-row:last-child{border-bottom:none}\n")
      (insert ".spine-selected{background:var(--pico-secondary-background)}\n")
      (insert ".spine-glyph{width:1.5rem;text-align:center;flex-shrink:0}\n")
      (insert ".spine-title{flex:1;min-width:0}\n")
      (insert ".spine-trail{font-size:0.85em;color:var(--pico-muted-color)}\n")
      (insert ".spine-tags{font-size:0.85em;color:var(--pico-muted-color)}\n")
      (insert ".spine-detail{margin:0 0 0 2rem;border-left:2px solid var(--pico-primary)}\n")
      (insert ".spine-detail p{margin-bottom:0.3rem}\n")
      (insert ".spine-detail footer{margin-top:0.5rem}\n")
      (insert "mark.want{background:var(--pico-mark-background);"
              "color:var(--pico-mark-color)}\n")
      (insert "mark.reading{background:#faeeda;color:#854f0b}\n")
      (insert "mark.read{background:#e1f5ee;color:#085041}\n")
      (insert "mark.abandoned{background:var(--pico-muted-color);"
              "color:var(--pico-background-color)}\n")
      (insert "article{margin-bottom:0}\n")
      (insert "article header{padding-bottom:0.5rem;margin-bottom:0.5rem}\n")
      (insert "</style>\n")
      (insert "</head>\n<body>\n")
      (insert "<main class=\"container\">\n")
      (insert "<article>\n")
      (insert (format "<header><strong>spine</strong>"
                      "<small>%d books · %d reading</small></header>\n"
                      total reading-count))
      ;; Each group in order
      (dolist (status order)
        (let ((group-books (nreverse (gethash status grouped))))
          (when group-books
            (insert (format "<hgroup><h2>%s</h2><small>%d</small></hgroup>\n"
                            status (length group-books)))
            (dolist (book group-books)
              (let ((selected (equal (plist-get book :id) selected-id)))
                (insert (format "<div class=\"spine-row%s\">\n"
                                (if selected " spine-selected" "")))
                ;; Format glyph (emoji)
                (let ((fmt (plist-get book :format)))
                  (insert (format "<span class=\"spine-glyph\">%s</span>\n"
                                  (cond ((equal fmt "hardcover") "📖")
                                        ((equal fmt "ebook")    "📱")
                                        ((equal fmt "audiobook") "🎧")
                                        (t                      "")))))
                ;; Title + author
                (insert "<span class=\"spine-title\">")
                (insert (spine--h (plist-get book :title)))
                (let ((author (plist-get book :author)))
                  (when author
                    (insert (format " <small>%s</small>"
                                    (spine--h author)))))
                (insert "</span>\n")
                ;; Tags
                (let ((tags (plist-get book :tags)))
                  (when tags
                    (insert (format "<small class=\"spine-tags\">%s</small>\n"
                                    (mapconcat (lambda (tag) (concat ":" tag ":"))
                                               tags " ")))))
                ;; Recommendation trail
                (let ((rec-by (plist-get book :rec_by))
                      (rec-note (plist-get book :rec_note)))
                  (when (and rec-by (> (length rec-by) 0))
                    (insert
                     (format "<span class=\"spine-trail\">%s%s</span>\n"
                             (spine--h rec-by)
                             (if (and rec-note (> (length rec-note) 0))
                                 (concat ": " (spine--h rec-note))
                               "")))))
                ;; Status pill
                (let ((status (or (plist-get book :status) "WANT")))
                  (insert (format "<mark class=\"%s\">%s</mark>\n"
                                  (downcase status) (downcase status))))
                ;; Expanded detail
                (when selected
                  (insert "<blockquote class=\"spine-detail\">\n")
                  (dolist (note (plist-get book :notes))
                    (insert (format "<p><small>[%s]</small> %s</p>\n"
                                    (spine--h (car note))
                                    (spine--h (cadr note)))))
                  (let ((parts nil))
                    (let ((rating (plist-get book :rating)))
                      (when (and rating (> (length rating) 0))
                        (push (format "Rating: %s/5" (spine--h rating)) parts)))
                    (let ((isbn (plist-get book :isbn)))
                      (when (and isbn (> (length isbn) 0))
                        (push (format "ISBN: %s" (spine--h isbn)) parts)))
                    (let ((fmt (plist-get book :format)))
                      (when (and fmt (> (length fmt) 0))
                        (push (format "Format: %s" (spine--h fmt)) parts)))
                    (let ((added (plist-get book :added)))
                      (when (and added (> (length added) 0))
                        (push (format "Added: %s" (spine--h added)) parts)))
                    (when parts
                      (insert (format "<footer>%s</footer>\n"
                                      (mapconcat #'identity (nreverse parts) " · ")))))
                  (insert "</blockquote>\n"))
                (insert "</div>\n"))))))
      (insert "</article>\n")
      (insert "</main>\n</body>\n</html>\n")
      (buffer-string))))

(defun spine-render-empty-state ()
  "Render a page indicating no books file was found."
  (concat "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n"
          "<meta charset=\"utf-8\">\n"
          "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
          "<title>Spine</title>\n"
          "<link rel=\"stylesheet\""
          " href=\"https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css\">\n"
          "</head>\n<body>\n"
          "<main class=\"container\">\n"
          "<article>\n"
          "<header><strong>spine</strong></header>\n"
          "<p>No books yet.</p>\n"
          "</article>\n"
          "</main>\n</body>\n</html>"))

(defvar spine-skip-server-start nil
  "When non-nil, do not start the HTTP server.
Set by test harnesses that only need the model functions.")

;; --- handlers ---------------------------------------------------------

(defservlet index text/html (path query request)
  (let ((books (spine-books)))
    (if books
        (insert (spine-render-index books (cadr (assoc "id" query))))
      (insert (spine-render-empty-state)))))

(defun httpd/ (proc uri-path query request)
  "Redirect root to /index."
  (httpd-redirect proc "/index" 302))

;; --- start ------------------------------------------------------------
(unless spine-skip-server-start
  (setq httpd-host spine-host)
  (setq httpd-port spine-port)
  (httpd-start)
  (message "Spine listening on http://%s:%d"
           (or spine-host "localhost") spine-port))

(provide 'spine)
;;; spine.el ends here