;;; posts.el --- Emacs extension for Andromeda/Posts -*- lexical-binding: t; -*-

;;

;; Copyright (C) 2026 Steve Simkins

;;

;; Author: Steve Simkins <contact@stevedylan.dev>

;; Version: 0.0.1

;; Keywords: tools blogging extension

;; Homepage: https://github.com/stevedylandev/andromeda

;; Package-Requires: ((emacs "27.1"))

;;

;; This file is not part of GNU Emacs.

;;

;;; Commentary:

;; Sends micro posts to an Andromeda/posts instance.

;; Run M-x posts-compose, fill in the `name: value' fields at the top

;; (see `posts-fields'), write the content below, then press C-c C-c.

;;

;;; Code:

(require 'url)

(require 'json)

(require 'subr-x)

(require 'auth-source-pass)

(defgroup posts nil

  "Andromeda/posts."

  :group 'tools)

(defcustom posts-pass-entry "andromeda/posts-api-key"

  "Name of the `pass' entry holding the API key."

  :type 'string

  :group 'posts)

(defun posts--api-key ()

  "Return the API key from password-store."

  (or (auth-source-pass-get 'secret posts-pass-entry)

      (user-error "No pass entry `%s'" posts-pass-entry)))

(defcustom posts-endpoint "https://posts.stevedylan.dev/api/posts"

  "URL that receives the JSON post."

  :type 'string

  :group 'posts)

;;;; Fields

(defcustom posts-fields

  '(("title")

    ("status" :default "draft" :choices ("draft" "published")))

  "Header fields read from the top of the compose buffer as `name: value'.

Each entry is (NAME . PLIST).  PLIST keys: `:required', `:default',

`:choices'.  Add an entry to support a new field; it is sent as a JSON

key of the same name."

  :type '(alist :key-type string :value-type plist)

  :group 'posts)

(defun posts--parse-buffer ()

  "Return (FIELDS . CONTENT) parsed from the current buffer.

FIELDS is an alist of raw (NAME . VALUE) strings from the leading

`name: value' lines.  CONTENT is everything after them."

  (save-excursion

    (goto-char (point-min))

    (let (fields)

      (while (looking-at "^\\([[:alnum:]_-]+\\):[ \t]*\\(.*?\\)[ \t]*$")

        (push (cons (downcase (match-string-no-properties 1))

                    (match-string-no-properties 2))

              fields)

        (forward-line 1))

      (cons (nreverse fields)

            (string-trim

             (buffer-substring-no-properties (point) (point-max)))))))

(defun posts--resolve-fields (parsed)

  "Validate PARSED against `posts-fields'; return alist with defaults applied."

  (dolist (p parsed)

    (unless (assoc (car p) posts-fields)

      (user-error "Unknown field `%s'" (car p))))

  (delq nil

        (mapcar

         (lambda (spec)

           (let* ((name (car spec))

                  (opts (cdr spec))

                  (raw (cdr (assoc name parsed)))

                  (val (if (and raw (not (string-empty-p raw)))

                           raw

                         (plist-get opts :default)))

                  (choices (plist-get opts :choices)))

             (when (and (plist-get opts :required) (null val))

               (user-error "Field `%s' is required" name))

             (when (and val choices (not (member val choices)))

               (user-error "Bad %s `%s' (one of: %s)"

                           name val (string-join choices ", ")))

             (and val (cons name val))))

         posts-fields)))

(defun posts--payload (fields content)

  "Build the JSON plist from FIELDS alist and CONTENT."

  (append (mapcan (lambda (f) (list (intern (concat ":" (car f))) (cdr f)))

                  fields)

          (list :content content)))

;;;; Sending

(defun posts (fields content)

  "Send a post to `posts-endpoint' as JSON.

FIELDS is an alist of (NAME . VALUE) strings, CONTENT the body."

  (interactive

   (let ((title (read-string "Title (optional): ")))

     (list (delq nil (list (and (not (string-empty-p title))

                                (cons "title" title))

                           (cons "status" "draft")))

           (read-string "Content: "))))

  (let ((url-request-method "POST")

        (url-request-extra-headers

         `(("Content-Type" . "application/json; charset=utf-8")

           ("X-API-Key" . ,(posts--api-key))))

        (url-request-data

         (encode-coding-string

          (json-serialize (posts--payload fields content))

          'utf-8)))

    (url-retrieve

     posts-endpoint

     (lambda (status)

       (unwind-protect

           (if (plist-get status :error)

               (message "Posts error: %S" (plist-get status :error))

             (goto-char (point-min))

             (re-search-forward "\r?\n\r?\n" nil t)

             (condition-case nil

                 (let ((resp (json-parse-buffer :object-type 'alist)))

                   (message "Posted: https://stevedylan.dev/now/%S" (alist-get 'slug resp)))

               (error (message "Posted (non-JSON response)"))))

         (kill-buffer (current-buffer))))

     nil t)))

;;;; Compose buffer

(defvar posts-compose-mode-map

  (let ((m (make-sparse-keymap)))

    (define-key m (kbd "C-c C-c") #'posts-compose-submit)

    (define-key m (kbd "C-c C-k") #'posts-compose-cancel)

    m)

  "Keymap for `posts-compose-mode'.")

(define-derived-mode posts-compose-mode text-mode "Posts"

  "Compose a post.  Leading `name: value' lines are fields, the rest is content.

\\{posts-compose-mode-map}"

  (setq header-line-format

        "Fields as `name: value' lines, then content.  C-c C-c to send, C-c C-k to cancel"))

;;;###autoload

(defun posts-compose ()

  "Open a buffer to compose a post."

  (interactive)

  (pop-to-buffer (get-buffer-create "*posts-compose*"))

  (erase-buffer)

  (posts-compose-mode)

  (dolist (spec posts-fields)

    (insert (car spec) ": " (or (plist-get (cdr spec) :default) "") "\n"))

  (insert "\n")

  (goto-char (point-min))

  (end-of-line))

(defun posts-compose-submit ()

  "Parse the compose buffer and send it."

  (interactive)

  (let* ((parsed (posts--parse-buffer))

         (fields (posts--resolve-fields (car parsed)))

         (content (cdr parsed)))

    (when (string-empty-p content)

      (user-error "Content is empty"))

    (posts fields content)

    (quit-window t)))

(defun posts-compose-cancel ()

  "Discard the compose buffer."

  (interactive)

  (quit-window t))

(provide 'posts)

;;; posts.el ends here