#.(progn
    (asdf:defsystem :fwoar.gallery
      :depends-on (:lquery
                   :araneus
                   :drakma
                   :clack
                   :yason
                   :ningle
                   :lass))
    (ql:quickload :fwoar.gallery)
    nil)

(defpackage :fwoar.gallery
  (:use :cl :araneus :alexandria :serapeum)
  (:export ))
(in-package :fwoar.gallery)

(defvar *url*)
(defvar *gallery*)

(defmacro new (class &rest initializer-syms)
  `(make-instance ,class
                  ,@(mapcan (serapeum:op (list (alexandria:make-keyword _1) _1))
                            initializer-syms)))

(defclass gallery ()
  ((%images :initarg :images :initform () :reader images)))

(defun make-gallery (images)
  (new 'gallery images))

(defclass page ()
  ((%gallery :initarg :gallery :reader gallery)
   (%page :initarg :page :initform 1 :reader page)))

(defun make-page (gallery page)
  (new 'page gallery page))

(defclass image ()
  ((%url :initarg :url :initform (error "need url for image") :reader url)))
(defclass video ()
  ((%url :initarg :url :initform (error "need url for video") :reader url)))

(defmethod print-object ((o image) s)
  (format s "#.(make-image \"~a\")" (url o)))
(defmethod print-object ((o video) s)
  (format s "#.(make-video \"~a\")" (url o)))
(defmethod print-object ((o gallery) s)
  (if *print-readably*
      (format s "#.(make-gallery (list ~{~a~^~%~22t~}))" (images o))
      (format s "#.(make-gallery (~a images))" (length (images o)))))

(defun make-image (url)
  (new 'image url))
(defun make-video (url)
  (new 'video url))

(defun page->gallery (dom base-url)
  (check-type dom plump:node)
  (make-gallery
   (coerce (lquery:$ 
             (inline dom)
             "a" 
             (attr "href") 
             (filter (lambda (u) (search "jpg" u)))
             (filter (complement (lambda (u) (search "thumb" u))))
             (map (lambda (u)
                    (with-output-to-string (s)
                      (puri:render-uri
                       (puri:merge-uris u base-url)
                       s))))
             (map 'make-image))
           'list)))


(define-controller root (params gallery)
  (let ((page (make-page gallery
                         (parse-integer
                          (or (cdr (assoc "page" params
                                          :test #'equalp))
                              "1")))))
    page))

(defmacro hostname-case (uri &body cases)
  `(serapeum:string-case (puri:uri-host ,uri)
     ,@cases))

(defun get-site (uri)
  (hostname-case uri
    ("gfycat.com" :gfycat)
    ("imgur.com" :imgur)
    ("i.redd.it" :ireddit)
    ("v.redd.it" :vreddit)))

(defgeneric transform-url (site uri)
  (:method (_ uri)
    (declare (ignore _))
    (make-image (puri:render-uri uri nil)))
  (:method ((site (eql :gfycat)) uri)
    (make-video
     (format nil "~a"
             (puri:render-uri
              (fw.lu:prog1-bind (uri (puri:copy-uri uri))
                (setf (puri:uri-host uri) "gfycat.com"
                      (puri:uri-path uri) (format nil "/ifr~a" (puri:uri-path uri))))
              nil))))
  (:method ((site (eql :imgur)) uri)
    (make-image
     (format nil "~a.jpg"
             (puri:render-uri
              (fw.lu:prog1-bind (uri (puri:copy-uri uri))
                (setf (puri:uri-host uri) "i.imgur.com"))
              nil))))
  (:method ((site (eql :vreddit)) uri)
    (make-video (puri:render-uri
                 (fw.lu:prog1-bind (uri (puri:copy-uri uri))
                   (setf (puri:uri-path uri)
                         (format nil "~a/HLSPlaylist.m3u8"
                                 (puri:uri-path uri))))
                 nil))))

(defun ensure-uri (uri)
  (etypecase uri
    (string (puri:parse-uri uri))
    (puri:uri uri)))

(defun process-uri-list (uris)
  (loop for raw-uri in uris
        for uri = (ensure-uri raw-uri)
        for transformed = (transform-url (get-site uri) uri)
        when transformed
          collect transformed))

(spinneret:deftag css (body attrs)
  `(:style :type "text/css"
           ,@attrs
           (:raw
            ,(format nil "~%")
            ,(apply 'lass:compile-and-write
                    body)
            )))

(spinneret:deftag js (body attrs)
  `(:script :type "text/javascript"
            ,@attrs
            (:raw
             ,(format nil "~%")
             (ps:ps
               ,@body))))

(defun gallery-css ()
  (spinneret:with-html
    (css
      (:let ((bottom-gap 2em)
             (gallery-height (calc (- 100vh 2em))))
        (*
         :box-sizing border-box)
        (html
         :outline "thin solid black")
        ((:or body html div section)
         :margin 0
         :padding 0)

        (.gallery
         :display block
         :background "#888"
         :height #(gallery-height)
         :overflow-y scroll
         :scroll-snap-type "y mandatory"

         :flex-wrap wrap)

        ((.gallery img)
         :width 100%
         :height 100%
         :scroll-snap-align start
         :object-fit contain)
        ((.gallery video)
         :width 100%
         :height 100%
         :scroll-snap-align start
         :object-fit contain)
        ((.gallery iframe)
         :width 100%
         :height 100%
         :scroll-snap-align start
         :object-fit contain)
        ))))

(defun gallery-js ()
  (js
   (ps:chain #() for-each
             (call (ps:chain document
                             (query-selector-all ".gallery > div"))
                   (lambda (it)
                     (ps:chain it (add-event-listener
                                   "click"
                                   (lambda ()
                                     (ps:chain #() for-each
                                               (call (ps:chain document (query-selector-all ".expanded"))
                                                     (lambda (other)
                                                       (unless (eql other it)
                                                         (ps:chain other class-list (remove "expanded"))))))
                                     (ps:chain it class-list (toggle "expanded"))))))))) )


(defmethod view :around ((name (eql 'root)) (model page))
  (spinneret:with-html-string
    (:html
     (:head
      (gallery-css))
     (:body
      (let ((*gallery* (make-gallery (subseq (images (gallery model))
                                             (* 52 (1- (page model)))
                                             (min (* 52 (page model))
                                                  (length (images (gallery model))))))))
        (call-next-method))
      (when (<= (* 52 (page model))
                (length (images (gallery model))))
        (:a :href (format nil "/?page=~d" (1+ (page model)))
            :style "width: 100%; text-align: center; display: inline-block;"
            "next"))
      (gallery-js)))))

(define-view root ((model page))
  (spinneret:with-html
    (:section.gallery
     (loop for img in (images *gallery*)
           do (call-current-view img)))))

(define-view root ((model image))
  (spinneret:with-html
    (:img :src (url model))))

(define-view root ((model video))
  (spinneret:with-html
    (if (string-contains-p "/ifr/" (url model))
        (:iframe :src (url model))
        (:video :autoplay "autoplay"
                :loop "loop"
                (:source :src (url model)
                         :type "video/mp4")))))

(defun initialize-app (app gallery)
  (defroutes app
    (("/") (as-route 'root :gallery gallery))))

(defun get-reddit-items (r)
  (process-uri-list
   (mapcar (lambda (i)
             (fw.lu:dive '("data" "url") i))
           (fw.lu:dive '("data" "children") r))))

(defun main (url)
  (let* ((app (make-instance 'ningle:<app>))
         (gallery (page->gallery (plump:parse
                                  (babel:octets-to-string (drakma:http-request url :force-binary t)
                                                          :encoding :latin-1))
                                 url)))
    (initialize-app app gallery)
    (clack:clackup app)))

(defun reddit-main (subreddits)
  (let* ((app (make-instance 'ningle:<app>))
         (gallery (make-gallery
                   (mapcan
                    (lambda (subreddit)
                      (get-reddit-items
                       (yason:parse
                        (babel:octets-to-string
                         (drakma:http-request (format nil "https://reddit.com/r/~a.json" subreddit)
                                              :force-binary t)
                         :encoding :latin-1))))
                    subreddits))))
    (setf *gallery* gallery)
    (initialize-app app gallery)
    (clack:clackup app)))

(defun cl-user::fwoar.gallery.main (version init)
  (ecase version
    (:reddit (reddit-main init))
    (:dir (main init))))