(in-package :cl-user)

 (in-package :whitespace.tables)
 (cl-annot.syntax:enable-annot-syntax)

 @export-class
 (defclass rss_feed_store ()

   ((id          :col-type serial :initarg :id          :accessor rfs-id)

    (title       :col-type text   :initarg :title       :accessor rfs-title       :col-default "")
    (link        :col-type text   :initarg :link        :accessor rfs-link        :col-default "")

    (description :col-type text   :initarg :description :accessor rfs-description :col-default "")
    (fetch-url   :col-type text   :initarg :fetch-url :accessor rfs-fetch-url   :col-default ""))
   (:metaclass dao-class)

   (:keys id))
 

 (deftable rss_feed_store
   (!dao-def)
   (!unique "link"))

 @export-class
 (defclass rss_item_store ()

   ((id          :col-type serial  :initarg :id          :accessor ris-id)
    (title       :col-type text    :initarg :title       :accessor ris-title       :col-default "")
    (link        :col-type text    :initarg :link        :accessor ris-link        :col-default "")
    (description :col-type text    :initarg :description :accessor ris-description :col-default "")
    (comments    :col-type text    :initarg :comments    :accessor ris-comments    :col-default "")
    (enclosure   :col-type text    :initarg :enclosure   :accessor ris-enclosure   :col-default "")
    (guid        :col-type text    :initarg :guid        :accessor ris-guid        :col-default "")
    (pub-date    :col-type text    :initarg :pub-date    :accessor ris-pub-date    :col-default "")
    (source      :col-type text    :initarg :source      :accessor ris-source      :col-default "")
    (feed        :col-type integer :initarg :feed        :accessor ris-feed))

   (:metaclass dao-class)

   (:keys id))
 

 (deftable rss_item_store
   (!dao-def)
   (!foreign "rss_feed_store" "feed" "id" :on-delete :cascade :on-update :cascade)
   (!unique "guid"))

 @export-class
 (defclass reader_user ()
   ((id :col-type serial)
    (join-date :col-type timestamp :accessor join-date :col-default (:now))
    (foreign-id :col-type string :initarg :foreign-id :accessor user-foreign-id :unique t)
    (name :col-type string :initarg :name :accessor user-name)
    (email :col-type string :initarg :email :accessor user-email)
    (first-name :col-type (or string s-sql:db-null) :initarg :first-name :accessor user-first-name)
    (gender :col-type (or string s-sql:db-null) :initarg :gender :accessor user-gender)
    (last-name :col-type (or string s-sql:db-null) :initarg :last-name :accessor user-last-name)
    (link :col-type (or string s-sql:db-null) :initarg :link :accessor user-link)
    (locale :col-type (or string s-sql:db-null) :initarg :locale :accessor user-locale))

   (:metaclass dao-class)

   (:keys id))
 

 (deftable reader_user
   (!dao-def))

 
 @export-class
 (defclass subscriptions ()
   ((id :col-type serial)
    (uid :col-type integer :initarg :uid :accessor subscription-uid)
    (feedid :col-type integer :initarg :feedid :accessor subscription-feedid))
   (:unique (uid feedid))

   (!foreign "rss_feed_store" "feedid" "id" :on-delete :cascade :on-update :cascade)
   (:metaclass dao-class)

   (:keys id))
 

 (deftable subscriptions
   (!dao-def)
   (!foreign "rss_feed_store" "feedid" "id" :on-delete :cascade :on-update :cascade)
   (!foreign "reader_user" "uid" "id" :on-delete :cascade :on-update :cascade)
   (!unique '(uid feedid)))

 
 @export
 (defgeneric get-dao-for (obj &optional link)
   (:documentation "Take an object an return the equivalent dao object. Use link to specify a single
                    foreign key relationship---this probably should be generalized further"))
 
 @export
 (defgeneric serialize (cls &optional output-transform pair-transform))
 
 @export
 (defmacro defserializer ((specializes) &body slots)
   (with-gensyms (obj o-t p-t)
     `(defmethod serialize ((,obj ,specializes) &optional (,o-t #'identity) (,p-t #'%default-pair-transform))
       (transform-result (,o-t ,p-t)
         (slots-to-pairs ,obj ,slots)))))
 
 (defmethod serialize ((obj sequence) &optional (o-t #'identity) (p-t #'%default-pair-transform))
   (iterate (for item in-sequence obj)
            (collect (serialize item o-t p-t))))
 
 ; this is the interface to be used
 (defserializer (rss_feed_store)
   title link description fetch-url)
 
 (defserializer (rss_item_store)
   title link description fetch-url)
 
 @export
 (defun store-item-dao (serialized-rss-item link)
   (pomo:ensure-transaction
     (apply #'postmodern:make-dao
            (list* 'rss_item_store :feed link
                   (iterate (for (k . v) in-sequence serialized-rss-item)
                            (appending (list k v)))))))
 
 @export
 (defun store-feed-dao (serialized-rss-feed &optional link)
   (declare (ignore link))
   (pomo:ensure-transaction
     (let* ((items nil)
            (rss_feed (apply #'postmodern:make-dao
                             (cons 'rss_feed_store
                                   (iterate (for (k . v) in-sequence serialized-rss-feed)
                                            (if (eql k :items)
                                              (setf items v)
                                              (appending (list k v))))))))
       (iterate (for item in items)
                (handler-case (pomo:with-savepoint store-item
                                (store-item-dao (serialize item) (slot-value rss_feed 'id)))
                  (cl-postgres-error:unique-violation ())))
       rss_feed)))
 
 

 #|

 (with-connection whitespace::*db-connection-info* 
   (with-transaction ()
     (create-table 'rss_feed_store)
     (create-table 'rss_item_store)
     (create-table 'reader_user)
     (create-table 'subscriptions)))

 |#