(in-package :inangulis.links)

(defparameter *submissions* nil)

(defclass submission ()
  ((headline  :initarg :headline  :col-type text :initform ""  :accessor s-headline)
   (url       :initarg :url       :col-type text :initform ""  :accessor s-url)
   (date      :initarg :date      :col-type timestamptz :initform "" :accessor s-date)
   (submitter :initarg :submitter :col-type (or s-sql:db-null integer) :accessor s-submitter)
   (curator   :initarg :curator   :col-type (or s-sql:db-null integer) :accessor s-curator)
   (approved  :initarg :approved  :col-type text :initform "" :accessor s-approved))
  (:metaclass pomo:dao-class)
  (:keys headline url))

(pomo:deftable submission
  (pomo:!dao-def) 
  (pomo:!foreign "public.user" "submitter" "id" :on-delete :set-null :on-update :cascade)
  (pomo:!foreign "public.user" "curator" "id" :on-delete :set-null :on-update :cascade))

#|
 |(pomo:with-connection (ubiquitous:value :db)
 |   (pomo:create-table 'submission))
 |#

(defun make-submission (headline url &key (approved ""))
  (alet 'submission
    (make-instance it :headline headline :url url :approved approved :date (current-date-string))))

(defun get-by-key (headline url)
  (car (postmodern:select-dao 'submission (:and (:= 'headline headline) (:= 'url url)))))

(defun alist-submission (alist &key nil-if-exists)
  (let* ((headline (cdr-assoc :headline alist :test #'string-equal))
         (url (cdr-assoc :url alist :test #'string-equal))
         (approved (or (cdr-assoc :approved alist :test #'string-equal) ""))   
         (result (make-submission headline url :approved approved)))
    (with-slots ((headline inangulis.links:headline) (url inangulis.links:url)) result
      (aif (get-by-key headline url)
        (unless nil-if-exists it)
        result))))

(defmethod s-date ((object submission))
  (with-slots (date) object
    (local-time:format-timestring nil date :format local-time:+rfc-1123-format+)))

(defmethod print-object ((obj submission) s)
  (print-unreadable-object (obj s :type t :identity t)
    (with-slots (headline url approved) obj
      (format s "H: ~s U: ~s A: ~s" headline url approved))))

(defmacro with-submissions (&body b)
  `(with-db
     (let ((*submissions* (postmodern:select-dao 'submission t "date desc")))
       ,@b)))

(defun submission-alist (submission)
  (slots-to-pairs submission
                  (headline
                    url
                    date
                    approved)))


(mustache-view root (user . links) #p"static/index.mustache.html"
  :links (mapcar #'submission-alist links)
  :user (when user (inangulis.user:user-alist user)))

(define-controller root (params)
  (with-submissions
    (ningle:with-context-variables (session)
      (handler-case
        (cl-oid-connect.utils:ensure-logged-in
          (cl-oid-connect.utils:redirect-if-necessary session
            (cons (gethash :app-user session)
                  *submissions*)))
        (cl-oid-connect.utils:user-not-logged-in (c) (cons nil *submissions*))))))

(defun submit (params)
  (ningle:with-context-variables (session)
    (let* ((app-user (gethash :app-user session)))
      (awhen (alist-submission params :nil-if-exists t)
        (when app-user
          (setf (s-submitter it)
                (slot-value app-user 'inangulis.user:id)))
        (postmodern:insert-dao it)
        (push it *submissions*))))) 

;; View Controllers
(define-controller murmur (params)
  (sleep 0.01)
  (submit params))

(define-view murmur (model)
  '(302 (:location "/") ("Done"))) 

(defmethod controller :around ((name (eql 'curate)) params &key)
  (cl-oid-connect.utils:require-login
    (call-next-method)))

(define-controller curate (params)
    (let* ((session (ningle:context :session))
           (app-user (gethash :app-user session))
           (approval (string-downcase (str-assoc "approved" params :test #'equalp)))
           (submission (alist-submission params)))
      (setf1 ((s-curator submission) (slot-value app-user 'inangulis.user:id))
             ((s-approved submission) (ccase (elt approval 0)
                                     (#\+ "approved")
                                     (#\- "rejected"))))
      (postmodern:update-dao submission)))

(define-view curate (params)
  '(302 (:location "/") ("Done")))