(cl:in-package :fwoar.web-lisp)

(defclass web-lisp-app (ningle:<app>)
  ())

(defun string-return (s)
  `(200 () (,s)))

(defmacro with-json-string ((s &rest args &key indent) &body body)
  "Set up a JSON streaming encoder context, then evaluate BODY.
Return a string with the generated JSON output."
  (declare (ignore indent))
  `(with-output-to-string (,s)
     (with-open-stream (,s (yason:make-json-output-stream s ,@args))
       ,@body)))

(deftype simple-json-type ()
  '(or
    (member yason:true yason:false t)
    real string null))
(deftype compound-json-type ()
  '(or
    (array *)
    list
    hash-table))
(deftype json-type ()
  '(or simple-json-type compound-json-type))
(defun encodable (it)
  (typep it
         'json-type))

(defun jb (it)
  (if it
      'yason:true
      'yason:false))

(defmethod araneus:routes progn ((app web-lisp-app))
  (setf (ningle:route app "/systems" :method :get)
        (lambda (params)
          (declare (ignore params))
          (string-return
           (with-json-string (s :indent t)
             (yason:encode (asdf:registered-systems)
                           s))))

        (ningle:route app "/packages" :method :get)
        (lambda (params)
          (declare (ignore params))
          (string-return
           (with-json-string (s :indent t)
             (yason:encode (mapcar 'package-name
                                   (list-all-packages))
                           s))))

        (ningle:route app "/packages/:package-name" :method :get)
        (lambda (params)
          (let ((package-name (substitute #\/ #\:
                                          (serapeum:assocdr :package-name params
                                                            :test 'equal))))
            (string-return
             (yason:with-output-to-string* (:indent t)
               (yason:with-object ()
                 (yason:encode-object-element "package" package-name)
                 (yason:with-object-element ("symbols")
                   (yason:with-array ()
                     (do-external-symbols (sym package-name)
                       (yason:with-object ()
                         (yason:encode-object-elements
                          "name" (symbol-name sym)
                          "value-bound" (jb (boundp sym))
                          "function-bound" (jb (fboundp sym))
                          "macro-bound" (jb (macro-function sym))))))))))))

        (ningle:route app "/packages/:package-name/describe/:symbol-name" :method :get)
        (lambda (params)
          (let ((package-name (serapeum:assocdr :package-name params
                                                :test 'equal))
                (symbol-name (serapeum:assocdr :symbol-name params
                                               :test 'equal)))
            (string-return
             (with-output-to-string (s)
               (describe (find-symbol symbol-name package-name)
                         s)))))))