(declaim (optimize (debug 3) (speed 0 ) (safety 3)) )

 (in-package #:inangulis)

 (defparameter *by-distinct* (make-hash-table :test #'equalp))
 (defparameter *users* (make-hash-table :test #'equalp))
 
 (defmethod print-object ((obj user) s)
   (print-unreadable-object (obj s :type t :identity t)
     (with-slots (uid email name moderator) obj
       (format s "U: ~s E: ~s N: ~s M: ~s" uid email name moderator))))
 
 
 
 (defun get-moderated (feeds)
   (remove-if (lambda (x) (not (equal x "approved"))) feeds :key #'s-approved))
 
 (defparameter *app* (make-instance 'ningle:<app>))

 
 (defun rebind-headers (app)
   (lambda (env)
     (format t "~&~%------------------@!@#$@#!$!@#$-----------------~%")
     (format t "~&~%~s"   ningle.context:*request*)
     (format t "~&~s~%" (alexandria:hash-table-alist (lack.request:request-headers ningle.context:*request*)))
     (format t "~&~s~%~%" (gethash "x-real-ip" (lack.request:request-headers ningle.context:*request*)))
     (awhen (gethash "x-real-ip" (lack.request:request-headers ningle.context:*request*))
       (format t "~&~s"   (lack.request:request-remote-addr ningle.context:*request*))  
       (setf (lack.request:request-remote-addr ningle:*request*) it)
       (setf (getf env :remote-addr) it)
       (format t "~&~s"   (lack.request:request-remote-addr ningle.context:*request*)))
     (funcall app env)))

 (defmacro i-defun (name (&rest args) &body body)
   `(defun ,name (,@args)
      (declare (ignorable ,@(loop for x in args
                                  if (not (char= (elt (symbol-name x) 0) #\&))
                                  collect x)))
      ,@body))
 

 (defmacro i-lambda ((&rest args) &body body)
   `(lambda (,@args)
      (declare (ignorable ,@args))
      ,@body))
 

 
 
 (defun get-feed-guid (item)
   (with-slots (alimenta:title alimenta:link) item
     (let ((hasher (ironclad:make-digest 'ironclad:sha256)))

       (ironclad:update-digest hasher (babel:string-to-octets alimenta:title))
       (ironclad:update-digest hasher (babel:string-to-octets alimenta:link))

       (ironclad:byte-array-to-hex-string (ironclad:produce-digest hasher)))))
 

 (defmethod run-route :around (name params &rest r)
   (declare (ignore r))
   (with-db
     (pomo:with-transaction ()
       (call-next-method))))
 
 (define-view login-page (model)
   `(200
     ()

     (,(cl-who:with-html-output-to-string (s)
         (:html
           (:head
             (:title "Login")
             (:link :rel "stylesheet" :href "/static/css/login.css"))
           (:body
             (:h1 "In Angulis")
             (:div :class "login-buttons"
              (:a :class "facebook" :href "/login/facebook" "Login With Facebook"))))))))
 

 (define-controller logout (params)

   (ningle:with-context-variables (session)

     (setf (gethash :userinfo session) nil)))

 (define-view logout (model)
   '(302 (:location "/")))
 
 (defmethod controller ((name (eql 'get-feed)) params &key moderated)

   (let ((feed (alimenta::make-feed :title "In Angulis" :link "http://in-angulis.com/feed"
                                    :description "Locus in quo sunt illi qui murmurant in angulis")))

     (prog1 feed

       (pomo:do-select-dao (('inangulis.links:submission submission)

                            (:raw (if moderated (pomo:sql (:= 'approved "approved")) "'t'"))
                            (:desc 'date))
         (alimenta::add-item-to-feed feed
                                     :title (s-headline submission)
                                     :link (s-url submission)
                                     :date (s-date submission)
                                     :next-id #'get-feed-guid

                                     :content "")))))
 
 (defparameter *tmp* nil)
 
 (define-view get-feed (feed)
   `(200 (:content-type "application/rss+xml") (,(plump:serialize (alimenta:generate-xml feed) nil))))
 
 (defmethod controller :around ((name (eql 'headlines)) params &key (moderated t moderated-p))
   (unless moderated-p
     (awhen (str-assoc "moderated" params :test #'string-equal)
            (setf moderated (and (> (length it) 0) (char= #\t (elt it 0)))
                  moderated-p t)))
   (if moderated-p
     (call-next-method name params :moderated moderated)  
     (call-next-method)))
 
 (defmethod controller ((name (eql 'headlines)) params &key (moderated t moderated-p))
   (let (result)
     (ningle.context:with-context-variables (session)
       (let* ((app-user (gethash :app-user session))

              (moderator-p (and app-user (slot-value app-user 'inangulis.user::moderator))))
         (pomo:do-select-dao (('inangulis.links:submission submission)

                              (:raw (cond 
                                      ((and moderator-p (not moderated-p)) "'t'")
                                      (moderated (pomo:sql (:= 'approved "approved")))
                                      (t "'t'")))
                              (:desc 'date))
           (push submission result))))
     result))
 
 (define-view headlines (columns) ;#p"static/headlines.mustache.html"
   (let ((sub-len (length columns))
         (columns (mapcar #'submission-alist columns)))
     (render-mustache #p"static/headlines.mustache.html"
                      `((:columns . (((:rows .  ,(subseq columns 0 (floor sub-len 3))))
                                     ((:rows .  ,(subseq columns (floor sub-len 3) (* 2 (floor sub-len 3)) )))
                                     ((:rows .  ,(subseq columns (* 2 (floor sub-len 3)) sub-len)))))))))
 
 (defroutes *app*
   (("/") (as-route 'root))
   (("/curo" :method :POST) (as-route 'curate)) 
   (("/feed") (as-route 'get-feed :moderated t))
   (("/firehose") (as-route 'get-feed))
   (("/headlines") (as-route 'headlines)) 
   (("/login") (as-route 'login-page))
   (("/logout") (as-route 'logout)) 
   (("/murmuro" :method :POST) (as-route 'murmur)))

 
 (cl-oid-connect::setup-oid-connect *app* (userinfo &rest args)
   (declare (ignore args))
   (let ((id (cdr (assoc :id userinfo))))

     (with-db

       (aif (car (postmodern:select-dao 'inangulis.user:user (:= 'uid id)))

         it

         (alet (make-instance 'inangulis.user:user)
           (with-slots ((uid inangulis.user::uid)
                        (name inangulis.user::name)
                        (email inangulis.user::email)) it

             (prog1 it
               (setf uid id
                     name (cdr (assoc :name userinfo))
                     email (cdr (assoc :email userinfo)))
               (pomo:with-transaction ()
                 (postmodern:insert-dao it)))))))))
 
 
 

 
 (let ((handler nil))

   (ubiquitous:restore :inangulis)

   (defun stop () (clack:stop (pop handler)))
 
   (defun start (&optional tmp)
     (cl-oid-connect:initialize-oid-connect
       (ubiquitous:value 'facebook 'secrets)
       (ubiquitous:value 'google 'secrets))
     (let ((server (if (> (length tmp) 1)
                     (intern (string-upcase (elt tmp 1)) 'keyword)
                     :hunchentoot)))
       (push (clack:clackup

               (funcall clack-errors:*clack-error-middleware*
                        (lack.builder:builder

                          :accesslog

                          (:static :path "/static/" :root #p"./static/")
                          :backtrace

                          :session

                          *app*

                          )

                       :debug (ubiquitous:defaulted-value t 'debug))

               :port 9090
               :server server)
             handler)))
 
   (defun restart-clack ()
     (do () ((null handler)) (stop))
     (start)))