(defpackage :cells-html-scraper
   (:use :cl :alexandria :serapeum :fw.lu :cells))
 
 (in-package :cells-html-scraper)
 
 (lquery:define-lquery-macro progn (nodes &rest args)
   `(lquery:$
      (inline ,nodes)
      ,@args))
 
 (lquery:define-lquery-function hn-score (item)
   (lquery:$1 (inline item)
              (next)
              ".score"
              (text)))
 
 (lquery:define-lquery-function hn-age (item)
   (lquery:$1 (inline item)
              (next)
              ".age"
              (text)))
 
 (lquery:define-lquery-function hn-comments (item)
   (lquery:$1 (inline item)
              (next)
              ".age"
              (lquery-funcs:next)
              (next)
              (next)
              (text)))
 
 (defclass hn-item ()
   ((%url :initarg :url :reader url)
    (%title :initarg :title :reader title)
    (%score :initarg :score :reader score)
    (%age :initarg :age :reader age)
    (%comments :initarg :comments :reader comments)))
 
 (defun make-hn-item (url title score age comments)
   (make-instance 'hn-item
                  :url (puri:parse-uri url)
                  :title title
                  :score (when score (parse-integer score :junk-allowed t))
                  :age age
                  :comments (when comments (parse-integer comments :junk-allowed t))))
 
 (defmodel hn-scraped ()
   ((%html :initarg :html
           :accessor html
           :initform (c-in ""))
    (%doc :reader %doc :initform (c? (plump:parse (^html))))
    (%hnmain :reader %hnmain
             :initform (c? (lquery:$1
                             (inline (^%doc))
                             "#hnmain")))
    (%body :reader %body
           :initform (c? (lquery:$
                           (inline (^%hnmain))
                           ".itemlist tr.athing")))
    (%titles :reader titles
             :initform (c? (lquery:$
                             (inline (^%body))

                             (combine (progn ".title a" (attr "href")

                                             (node))

                                      (progn ".title a" (text)

                                             (node))
                                      (hn-score)
                                      (hn-age)
                                      (hn-comments)))))
    (%items :reader items :initform (c? (map 'vector
                                             (op (apply 'make-hn-item _*))
                                             (^titles))))))
 
 (defmodel url-getter ()
   ((%url :initarg :url
          :accessor url
          :initform (c-in '()))
    (%text :reader text
           :initform (c? (let ((drakma:*text-content-types* (acons "application" "json" drakma:*text-content-types*)))
                           (drakma:http-request (^url)))))))
 
 (defun get-links (url)
   (restart-case (values (map 'list (compose (op (list* url _))
                                             #'cdr)
                              (remove-if-not (op (string= _ "alternate"))
                                             (lquery:$
                                               (initialize (drakma:http-request url))
                                               "link"
                                               (combine (attr "rel") (attr "href") (attr "type")))
                                             :key #'car))
                         "")
     (continue nil
       :report (lambda (stream) (format stream "skip url ~a" url))
       (values nil url))))

 
 #+lispworks
 (progn

   (defun request-new-items (interface page)
     (setf (cells-html-scraper::html (hnr-scraper interface))

           (drakma:http-request (format nil "https://news.ycombinator.com/~a" page))))

 
   (defun open-item (interface item)
     (capi:browser-pane-navigate (hnr-browser interface)
                                 (puri:render-uri (url item)
                                                  nil)))
   
     
   

   
   (capi:define-interface hn-reader ()

     ((scraper :reader hnr-scraper :initform (make-instance 'hn-scraped)))
     (:panes
      (pages capi:list-panel
             :reader hnr-pages
             :items (list "news" "newest" "ask" "show" "jobs")
             :initial-constraints '(:visible-max-width (:string "newestest"))
             :selection-callback 'request-new-items
             :callback-type :interface-item)
      (item-panel capi:list-panel
                  :reader hnr-item-panel
                  :print-function 'title
                  :selection-callback 'open-item
                  :callback-type :interface-item)
      (browser capi:browser-pane
               :reader hnr-browser
               :url "https://fwoar.co"))
     (:layouts
      (right-side capi:column-layout
                  '(item-panel :divider browser)
                  :y-ratios '(1 nil 2)
                  :uniform-size-p nil)
      (main-layout capi:row-layout
                   '(pages :divider right-side)
                   :visible-min-width '(:character 120)
                   :visible-min-height '(:character 40)
                   :x-ratios '(1 nil 2)
                   :uniform-size-p nil))
     (:default-initargs
      :layout 'main-layout
      :title "HN Reader"))
 
   (defmethod initialize-instance :after ((o hn-reader) &key)
     (cells:defobserver
      cells-html-scraper::%items ((self (eql (hnr-scraper o))) new-value)
      
      (capi:apply-in-pane-process
       #1=(hnr-item-panel o)
       (lambda (pane)
         (let ((cleaned-items (remove-if 'null new-value :key 'cells-html-scraper::title)))
           (capi:remove-items pane (constantly t))
           (capi:append-items pane 
                              cleaned-items)))
       #1#))
 
     (setf (cells-html-scraper::html (hnr-scraper o))
           (drakma:http-request "https://news.ycombinator.com/")))
   (defun startup ()
     (capi:display (make-instance 'hn-reader)))

   )