(in-package :twitter)

(defconstant +twitter-search-host+ "search.twitter.com")
(defconstant +twitter-search-port+ 80)
(defconstant +twitter-search-path+ "search.json")
(defun search-twitter (&key search-terms max-tweets page result-type since-id http-stream)
  (unless (member result-type '(:mixed :recent :popular nil))
    (error "Search result type should be one of :mixed :recent or :popular"))
  (let ((new-stream (not http-stream))
        (search-query-string))
    (setq search-query-string
          (format nil "~@[q=~{~A~^+~}~]~@[&rpp=~D~]~@[&page=~D~]~@[&result_type=~A~]~@[&since_id=~D~]" 
                  (mapcar #'url-encode search-terms)
                  (and max-tweets (min 100 max-tweets))
                  page
                  (and result-type (string-downcase (symbol-name result-type)))
                  since-id))
    (unwind-protect
        (progn
          (unless http-stream
            (setq http-stream (COMM:OPEN-TCP-STREAM +twitter-search-host+ +twitter-search-port+)))
            (format-to-http http-stream
                            "GET http://~A/~A?~A HTTP/1.1~A"
                            +twitter-search-host+
                            +twitter-search-path+
                            search-query-string
                            +crlf+)
            (format-to-http http-stream
                            "Host: ~A~A" +twitter-search-host+ +crlf+)
            (format-to-http http-stream +crlf+)
            (force-output http-stream)
            (skip-http-headers http-stream)
            (json:parse-json (read-line-from-http http-stream)))
      (when (and new-stream http-stream)
        (close http-stream)))))


(defconstant +twitter-stream-host+ "stream.twitter.com")
(defconstant +twitter-stream-protocol+ "http")
(defconstant +twitter-stream-port+ 80)
(defconstant +twitter-stream-path+ "/1/statuses/filter.json")
(defun stream-search-twitter (username callback search-terms &optional debug-stream)
  (let ((stop-now nil)
        (url (format nil "~A?track=~A" +twitter-stream-path+ (url-encode search-terms))))
    (MP:PROCESS-RUN-FUNCTION "Process Tweets" ()
                             #'(lambda ()
                                 (http-utils:with-http-debugging-stream (debug-stream)
                                   (oauth:with-oauth-debugging (debug-stream)
                                     (with-open-stream (hs (COMM:OPEN-TCP-STREAM +twitter-stream-host+ +twitter-search-port+ :keepalive t))
                                       (access-oauth-protected-resource hs :twitter username "POST" +twitter-stream-protocol+ +twitter-stream-host+ +twitter-stream-port+ url `(("track" ,search-terms))
                                                                        #'(lambda (stream) 
                                                                            (skip-http-headers stream)))
                                       (loop until stop-now
                                             for line = (read-line-from-http hs)
                                             do (funcall callback line)))))))
    #'(lambda () (setq stop-now t))))


;http://api.twitter.com/1/username/lists.xml?name=Twitter%20API%20Team
(defconstant +twitter-api-host+ "api.twitter.com")
(defconstant +twitter-api-port+ 80)
(defconstant +twitter-api-protocol+ "http")

(defun get-user-twitter-lists (username user)
  (let ((url (format nil "/1/~A/lists.json" (url-encode user))))
    (access-oauth-protected-resource nil :twitter username "GET" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url nil)))

(defun create-twitter-list (username listname &key mode description)
  (let ((method-parameters `(("name" ,listname)
                             ,@(when mode `(("mode" ,mode)))
                             ,@(when description `(("description" ,description)))))
        (url (format nil "/1/~A/lists.json?name=~A~@[&mode=~A~]~@[&description=~A~]"
                     (url-encode username) (url-encode listname) (and mode (url-encode mode)) (and description (url-encode description)))))
    (access-oauth-protected-resource nil :twitter username "POST" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters)))

(defun modify-twitter-list (username listid  &key name mode description)
  (let ((method-parameters `(,@(when name `(("name" ,name)))
                             ,@(when mode `(("mode" ,mode)))
                             ,@(when description `(("description" ,description)))))
        (url (format nil "/1/~A/lists/~d.json~@[?~*~]~@[name=~A~]~@[&~*~]~@[mode=~A~]~@[&~*~]~@[description=~A~]" 
                     (url-encode username) listid 
                     (or name mode description)
                     (and name (url-encode name))
                     name
                     (and mode (url-encode mode))
                     (or name mode)
                     (and description (url-encode description)))))
    (access-oauth-protected-resource nil :twitter username "POST" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters)))

(defun delete-twitter-list (username listid )
  (let ((url (format nil "/1/~A/lists/~d.json" (url-encode username) listid)))
    (access-oauth-protected-resource nil :twitter username "DELETE" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url nil)))

(defun get-twitter-list-tweets (username user list-id &key max-id since-id page per-page)
  (let ((method-parameters `(("include_entities" "true")
                             ,@(when max-id `(("max_id" ,max-id)))
                             ,@(when since-id `(("since_id" ,since-id)))
                             ,@(when page `(("page" ,page)))
                             ,@(when per-page `(("per_page" ,per-page)))))
        (url (format nil "/1/~A/lists/~D/statuses.json?include_entities=true~@[&max_id=~D~]~@[&since_id=~d~]~@[&page=~d~]~@[&per_page=~D~]"
                     (url-encode user) list-id 
                     max-id since-id page per-page)))
    (access-oauth-protected-resource nil :twitter username "GET" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters)))


(defun get-twitter-user-list-subscriptions (username user &key cursor)
  (let ((method-parameters `(,@(when cursor `(("cursor" ,cursor)))))
        (url (format nil "/1/~A/lists/subscriptions.json~@[?cursor=~D~]"
                     (url-encode user)
                     (url-encode cursor))))
    (access-oauth-protected-resource nil :twitter username "GET" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters)))

(defun get-twitter-list-members (username user listid &key cursor)
  (let ((method-parameters `(("include_entities" "true")
                             ,@(when cursor `(("cursor" ,cursor)))))
        (url (format nil "/1/~A/~D/members.json?include_entities=true~@[&cursor=~A~]"
                     (url-encode user)
                     listid
                     (url-encode cursor))))
    (access-oauth-protected-resource nil :twitter username "GET" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters)))

(defun get-all-twitter-list-members (username user listid)
  (loop with cursor = "-1"
        for members = (get-twitter-list-members username user listid :cursor cursor)
        for list-members = (JSON:GET-JSON-ATTRIBUTE members nil "users")
        while list-members
        do (setq cursor (JSON:GET-JSON-ATTRIBUTE members nil "next_cursor_str"))
        append (loop for i from 0
                     for user = (json:get-json-attribute list-members nil i)
                     while user
                     collect (json:get-json-attribute user nil "screen_name"))))

(defun add-twitter-users-to-list (username listid &rest users)
  (let ((usernames '())
        (userids '()))
    (loop for user in users
          do (cond ((stringp user)
                    (push (url-encode user) usernames))
                   ((integerp user)
                    (push user userids))
                   (t (error "Unknown user format found for ~S" user))))
    (let* ((screen-names (and usernames (format nil "~{~A~^,~}" usernames)))
           (user-ids (and userids (format nil "~{~d~^,~}" userids)))
           (method-parameters `(,@(when usernames `(("screen_name" ,screen-names)))
                                ,@(when userids `(("user_id" ,user-ids)))))
           (url (format nil "/1/~A/~D/members/create_all.json?~@[screen_name=~A~]~@[&~*~]~@[user_id=~A~]"
                        (url-encode username)
                        listid
                        screen-names (and screen-names user-ids)
                        user-ids)))
      (access-oauth-protected-resource nil :twitter username "POST" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters))))

(defun delete-twitter-user-from-list (username listid userid)
  (let* ((method-parameters `(("id" ,userid)))
         (url (format nil "/1/~A/~D/members/members.json?id=~D"
                      (url-encode username)
                      listid
                      userid)))
    (access-oauth-protected-resource nil :twitter username "DELETE" +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters)))

(defun twitter-user-in-list-p (username listid userid)
  (let* ((method-parameters `(("include_entities" "true")))
         (url (format nil "/1/~A/~D/members/~D.json?include_entities=true"
                      (url-encode username)
                      listid
                      userid))
         (response (access-oauth-protected-resource nil :twitter username "GET" 
                                                    +twitter-api-protocol+ +twitter-api-host+ +twitter-api-port+ url method-parameters)))
    (if (null (json:get-json-attribute response nil "error"))
        response
      nil)))

(defvar *debug-twitter-list-management* nil)
(defun create-twitter-list-based-on-search-result (username listdetails search-terms)
  (let ((users '())
        next-since)
    (loop for page from 1
          for search-results = (search-twitter :search-terms search-terms :max-tweets 100 :page page)
          for results = (json:get-json-attribute search-results nil "results")
          when results
          do (progn 
               (loop for i from 0
                     for tweet = (json:get-json-attribute results nil i)
                     for from_user = (and tweet (json:get-json-attribute tweet nil "from_user"))
                     while from_user
                     do (pushnew from_user users :test #'string=))
               (setq next-since (json:get-json-attribute search-results nil "max_id")))
          while (json:get-json-attribute search-results nil "next_page"))
    (when users
      (when *debug-twitter-list-management*
        (format *debug-twitter-list-management* "Adding users = ~~%" users))
      (destructuring-bind (listname listmode listdescription)
          listdetails
        (let* ((list (apply #'create-twitter-list username listname (nconc (and listmode (list :mode listmode) (and listdescription (list :description listdescription))))))
               ;; sometimes we get an error string rather than a JSON object
               (listid (and (listp list) (json:get-json-attribute list nil "id"))))
          (if listid
              (apply #'add-twitter-users-to-list username listid users)
            ;; if we don't get a list back just return the error string
            list))))
    next-since))

(defun update-twitter-list-based-on-search-result (username listname search-terms &optional (since 0))
  (let ((users '())
        (users-in-list (get-all-twitter-list-members username username listname))
        new-since)
    (loop for page from 1
          for search-results = (search-twitter :search-terms search-terms :max-tweets 100 :page page :since-id since)
          for results = (json:get-json-attribute search-results nil "results")
          do (setq new-since (json:get-json-attribute search-results nil "max_id"))
          when results
          do (loop for i from 0
                     for tweet = (json:get-json-attribute results nil i)
                     for from_user = (and tweet (json:get-json-attribute tweet nil "from_user"))
                     while from_user
                     unless (member from_user users-in-list :test #'string=)
                     do (pushnew from_user users :test #'string=))
          while (json:get-json-attribute search-results nil "next_page"))
    (when users
      (when *debug-twitter-list-management*
        (format *debug-twitter-list-management* "Adding users = ~A~%" users))
      (apply #'add-twitter-users-to-list username listname users))
    new-since))

(defparameter *manage-twitter-list-interval* 600)
(defun manage-twitter-list-based-on-search-result (username listdetails search-terms)
  (loop for next-since = (create-twitter-list-based-on-search-result username listdetails search-terms)
        then (update-twitter-list-based-on-search-result username (first listdetails) search-terms next-since)
        do (progn 
             (when *debug-twitter-list-management*
               (format *debug-twitter-list-management* "New since = ~d~%" next-since))
             (sleep *manage-twitter-list-interval*))))

(defun resume-manage-twitter-list-based-on-search-result (username listdetails search-terms since)
  (loop for next-since = (update-twitter-list-based-on-search-result username (first listdetails) search-terms since)
        then (update-twitter-list-based-on-search-result username (first listdetails) search-terms next-since)
        do (progn 
             (when *debug-twitter-list-management*
               (format *debug-twitter-list-management* "New since = ~d~%" next-since))
             (sleep *manage-twitter-list-interval*))))