(ns clj-bookmarks.core
  )

(defprotocol AnonymousBookmarkService
  (bookmarks [srv opts]
	     "The `bookmarks` function retrieves bookmarks from the
	     service according to criteria specified in `opts`:

             * `user`: only return bookmarks saved by this user
             * `tags`: only return bookmarks tagged with an element of this
                       seq

             At least one option must be specified.")
  (popular [srv]
	   "To get the most popular bookmarks from the service, call
           `popular`.")
  (recent [srv]
	  "To get the most recent bookmarks saved to the service by
          all users, call `recent`."))

(defprotocol AuthenticatedBookmarkService
  (query-bookmarks [srv opts]
	     "The `query-bookmarks` function retrieves bookmarks from the
	     service according to criteria specified in `opts`:

             * `user`: only return bookmarks saved by this user
             * `tags`: only return bookmarks tagged with an element of this
                       seq
             * `fromdt`: only return bookmarks saved on this date or later
             * `todt`: only return bookmarks saved on this date or earlier
             * `offset`: start returning bookmarks this many results into
                         the set
             * `limit`: return this many results

             When called with an empty `opts` map, `bookmarks` returns
             the 15 most recent bookmarks saved by the user.")
  (add-bookmark [srv url desc opts]
		"Bookmarks can be added by calling `add-bookmark` for
                the service, passing a URL, a description and a map of
                options that can have the following keys (none of them
                required):

                * `tags`: a seq of tags

                * `date`: the datestamp assigned to the bookmark
                          (default: now)
                * `shared`: make the item public (default: true)
                * `replace`: replace a bookmark if the given URL has
                             already been saved (default: true)")
  (delete-bookmark [srv url]
		   "The `delete-bookmark` function deletes the bookmark
                   for the given URL.")
  (suggested-tags [srv url]
		  "You can get a vector of suggestions for tags for a
                  given URL from the service using the
                  `suggested-tags` function.")
  (bookmark-info [srv url]
		 "Call `bookmark-info` to retrieve the bookmark
                 structure for `url`.")
  (last-update [srv]
		"Use `last-update` to find the timestamp when the user
		last updated his bookmarks."))

(ns clj-bookmarks.delicious
  (:use [clj-bookmarks core util])
  (:require [clj-http.client :as http]
	    [clojure.contrib.zip-filter.xml :as zfx]
	    [clojure.contrib.zip-filter :as zf]
	    [clojure.string :as string])
  (:import [java.util Date Locale]
	   [java.text SimpleDateFormat]))

(defn parse-posts
  [input]
  (zfx/xml-> (str->xmlzip input) :post
	    (fn [loc] {:url (zfx/attr loc :href)
		       :tags (parse-tags (zfx/attr loc :tag))
		       :hash (zfx/attr loc :hash)
		       :meta (zfx/attr loc :meta)
		       :desc (zfx/attr loc :description)
		       :extended (zfx/attr loc :extended)
		       :date (parse-date (zfx/attr loc :time))})))

(defn parse-result
  [input]
  (let [code (zfx/xml1-> (str->xmlzip input) (zfx/attr :code))]
    (if-not (= code "done")
      ; FIXME a better error concept, maybe?
      (throw (Exception. code))
      true)))

(defn parse-suggestions
  [input]
  (zfx/xml-> (str->xmlzip input) zf/children zfx/text))

(defn parse-update
  [input]
  (parse-date (zfx/xml1-> (str->xmlzip input) (zfx/attr :time))))

(defn posts-all
  [{:keys [endpoint] :as srv} opts]
  (letfn [(opt->param
	   [[k v]]
	   (cond
	    (= k :tags) [:tag (if (coll? v) (string/join " " v) v)]
	    (= k :limit)          [:results v]
	    (= k :offset)         [:start v]
	    (isa? (class v) Date) [k (format-date v)]
	    :else [k v]))]
    (let [params (into {} (map opt->param opts))]
      (-> (basic-auth-request srv (str endpoint "posts/all") params)
	  :body
	  (parse-posts)))))

(defn posts-add
  [{:keys [endpoint] :as srv}
  url desc opts]
  (letfn [(opt->param
	   [[k v]]
	   (cond
	    (= k :tags) [:tags (if (coll? v) (string/join " " v) v)]
	    (isa? (class v) Date) [k (format-date v)]
	    (= k :shared)  [:shared  (if v "yes" "no")]
	    (= k :replace) [:replace (if v "yes" "no")]
	    :else [k v]))]
    (let [params
	  (into {:url url :description desc} (map opt->param opts))]
      (-> (basic-auth-request srv (str endpoint "posts/add") params)
	  :body
	  parse-result))))

(defn posts-get
  [{:keys [endpoint] :as srv} url]
  (-> (basic-auth-request srv (str endpoint "posts/get") {:url url})
      :body
      parse-posts
      first))

(defn posts-delete
  [{:keys [endpoint] :as srv} url]
  (-> (basic-auth-request srv
			  (str endpoint "posts/delete") {:url url})
      :body
      parse-result))

(defn posts-suggest
  [{:keys [endpoint] :as srv} url]
  (-> (basic-auth-request srv
			  (str endpoint "posts/suggest") {:url url})
      :body
      parse-suggestions))

(defn posts-update
  [{:keys [endpoint] :as srv}]
  (-> (basic-auth-request srv (str endpoint "posts/update") {})
      :body
      parse-update))

(defrecord DeliciousV1Service [endpoint user passwd]
  AuthenticatedBookmarkService
  (query-bookmarks [srv opts] (posts-all srv opts))
  (add-bookmark [srv url desc opts] (posts-add srv url desc opts))
  (bookmark-info [srv url] (posts-get srv url))
  (delete-bookmark [srv url] (posts-delete srv url))
  (suggested-tags [srv url] (posts-suggest srv url))
  (last-update [srv] (posts-update srv)))

(def *del-base-rss-url* "http://feeds.delicious.com/v2/rss/")

(defn rss-date-format
  []
  (SimpleDateFormat. "EEE',' dd MMM yyyy HH:mm:ss Z" (Locale/US)))

(defn parse-rss-date
  [input]
  (.parse (rss-date-format) input))

(defn parse-rss-posts
  [input]
  (zfx/xml-> (str->xmlzip input) :channel :item
	     (fn [loc] {:url (zfx/xml1-> loc :link zfx/text)
			:tags (vec
			       (zfx/xml-> loc :category zfx/text))
			:desc (zfx/xml1-> loc :title zfx/text)
			:date (parse-rss-date
				  (zfx/xml1-> loc :pubDate zfx/text))})))

(defn rss-popular
  []
  (-> (http/get (str *del-base-rss-url* "popular/"))
      :body
      parse-rss-posts))

(defn rss-recent
  []
  (-> (http/get (str *del-base-rss-url* "recent/"))
      :body
      parse-rss-posts))

(defn rss-bookmarks
  [{:keys [tags user]}]
  (let [tags (if (string? tags) tags (string/join "+" tags))
	path (string/join "/" (filter (comp not string/blank?)
				      [(or user "tag") tags]))]
    (-> (http/get (str *del-base-rss-url* path))
	:body
	parse-rss-posts)))

(defrecord DeliciousRSSService []
  AnonymousBookmarkService
  (bookmarks [srv opts] (rss-bookmarks opts))
  (popular [srv] (rss-popular))
  (recent [srv] (rss-recent)))

(def *del-base-api-url* "https://api.del.icio.us/v1/")

(defn init-delicious
  ([] nil)
  ([user passwd] (init-delicious *del-base-api-url* user passwd))
  ([endpoint user passwd] (DeliciousV1Service. endpoint user passwd)))

(ns clj-bookmarks.pinboard
  (:use [clj-bookmarks core util])
  (:require [clj-http.client :as http]
	    [clojure.contrib.zip-filter.xml :as zfx]
	    [clj-bookmarks.delicious :as del]
	    [clojure.string :as string])
  (:import [java.util TimeZone Date]
	   [java.text SimpleDateFormat]))

(def *pb-base-api-url* "https://api.pinboard.in/v1/")

(def *pb-base-rss-url* "http://feeds.pinboard.in/rss/")

(defn rss-date-format
  []
  (doto (SimpleDateFormat. "yyyy-MM-dd'T'HH:mm:ss")
    (.setTimeZone (TimeZone/getTimeZone "UTC"))))

(defn parse-rss-date
  [input]
  (.parse (rss-date-format) input))

(defn parse-rss-posts
  [input]
  (zfx/xml-> (str->xmlzip input) :item
	    (fn [loc] {:url (zfx/xml1-> loc :link zfx/text)
		       :tags (parse-tags
			      (zfx/xml1-> loc :dc:subject zfx/text))
		       :desc (zfx/xml1-> loc :description zfx/text)
		       :date (parse-rss-date
			      (zfx/xml1-> loc :dc:date zfx/text))})))

(defn rss-popular
  []
  (-> (http/get (str *pb-base-rss-url* "popular/"))
      :body
      parse-rss-posts))

(defn rss-recent
  []
  (-> (http/get (str *pb-base-rss-url* "recent/"))
      :body
      parse-rss-posts))

(defn rss-bookmarks
  [{:keys [tags user]}]
  (let [tags (if (string? tags) [tags] tags)
	path (string/join "/" (filter (comp not nil?)
				      (cons  (if user (str "u:" user))
					     (map #(str "t:" %) tags))))]
    (-> (http/get (str *pb-base-rss-url* path))
	:body
	parse-rss-posts)))

(defrecord PinboardRSSService []
  AnonymousBookmarkService
  (bookmarks [srv opts] (rss-bookmarks opts))
  (popular [srv] (rss-popular))
  (recent [srv] (rss-recent)))

(defn init-pinboard
  ([] (PinboardRSSService.))
  ([user passwd] (del/init-delicious *pb-base-api-url* user passwd)))

(ns clj-bookmarks.util
  (:require [clj-http.client :as http]
	    [clojure.xml :as xml]
	    [clojure.zip :as zip]
	    [clojure.contrib.zip-filter.xml :as zf]
	    [clojure.contrib.zip-filter :as zfilter]
	    [clojure.string :as string])
  (:import [java.util TimeZone Date]
	   [java.text SimpleDateFormat]
	   [java.io StringReader]
	   [org.xml.sax InputSource]))

(defn string->input-source
  [s]
  (InputSource. (StringReader. (.trim s))))

(defn str->xmlzip
  [input]
  (-> input
      string->input-source
      xml/parse
      zip/xml-zip))

(defn date-format
  []
  (doto (SimpleDateFormat. "yyyy-MM-dd'T'HH:mm:ss'Z'")
    (.setTimeZone (TimeZone/getTimeZone "UTC"))))

(defn format-date
  [d]
  (.format (date-format) d))

(defn parse-date
  [input]
  (.parse (date-format) input))

(defn basic-auth-request
  [{:keys [user passwd]} url params]
  (http/get url {:query-params params
		 :basic-auth [user passwd]}))

(defn parse-tags
  [input]
  (vec (string/split input #"\s")))