(in-package :fwoar.rss-reader)

(defgeneric app (obj)
  (:documentation "the ningle app that is to be run"))

(defgeneric handler (obj)
  (:documentation "the clack handler representing the currently running application"))

(defclass+ rss-reader ()
  ((%feeds :initarg :feeds :accessor feeds)
   (%app :initform (make-instance 'ningle:<app>)
         :reader app)
   (%handler :accessor handler))
  (:documentation
   "A simple wrapper that ties a ningle app to a clack handler"))

(defun redirect (target)
  (lambda (_)
    (declare (ignore _))
    `(302 (:location ,target) ())))

(defmethod araneus:routes progn ((app rss-reader))
  (araneus:defroutes (app app)
    (("/") (redirect (format nil "/f/~(~a~)"
                             (feed-key
                              (car
                               (feeds app))))))
    (("/f/:feed") (lambda (params)
                    (optima:match params
                      ((optima.extra:alist (:feed . feed))
                       (araneus:run-route (feed-page (feeds app)
                                                     (find feed (feeds app)
                                                           :key 'feed-key
                                                           :test 'string-equal))
                                          params)))))))

(defun start (app)
  (setf (handler app)
        (clack:clackup (app app)))
  app)

(defvar *app*)

(defun unboundp (symbol)
  (not (boundp symbol)))

(defgeneric feed-key (object))
(defgeneric feed-url (object))

(fw.lu:defclass+ feed-reference ()
  ((%key :initarg :key :reader feed-key)
   (%url :initarg :url :reader feed-url)))

(fw.lu:defclass+ plump-cleaner
    ((feed-reference (key url)))
  ())

(defgeneric resolve-feed-reference (reference)
  (:method ((r feed-reference))
    (alimenta.pull-feed:pull-feed (feed-url r))))

(defgeneric prepare-feed-item-description (reference item)
  (:method ((r feed-reference) (item alimenta:item))
    (alimenta:description item))
  (:method ((r plump-cleaner) (item alimenta:item))
    (let ((description (alimenta:description item)))
      (when description
        (format t "~&aaaaa~%")
        (plump:text
         (plump:parse
          description))))))

(defun main ()
  (setf *app*
        (if (not (boundp '*app*))
            (start
             (araneus:routes
              (rss-reader (list
                           (feed-reference :techcrunch      "https://techcrunch.com/feed/")
                           (plump-cleaner  :coding-horror   "http://feeds.feedburner.com/codinghorror")
                           (feed-reference :daring-fireball "https://daringfireball.net/feeds/main")))))
            *app*)))