(in-package :jira-api)

(defun ensure-parent (object parent &key (err-if-nil t))
  (when (and (not err-if-nil) (null object))
    (return-from ensure-parent object))

  (unless (sheeple:parentp parent object)
    (push parent (sheeple:object-parents object))
    (sheeple:shared-init object))
  object)

(sheeple:defproto =status= () (name))
(sheeple:defproto =person= () (displayname emailaddress))
(sheeple:defproto =issue= () (fields key id self))
(sheeple:defproto =fields= () (summary description reporter creator assignee status comment))
(sheeple:defproto =issues= () (issues))
(sheeple:defmessage show (object &rest args))
(sheeple:defmessage fields-labels (fields))
(sheeple:defreply fields-labels ((fields =fields=))
  (sheeple:with-properties (labels) fields
    labels))

(sheeple:defproto =comment= () (self id author body))

(sheeple:defmessage points (issue))
(sheeple:defreply points ((issue =issue=))
  (sheeple:property-value (fields issue)
                          'customfield_10002))

(sheeple:defreply sheeple:shared-init ((issues =issues=) &key)
  (map nil (op (ensure-parent _ =issue=))
       (issues issues)))

(sheeple:defreply sheeple:shared-init :after ((comment =comment=) &key)
  (with-accessors ((author author)) comment
      (ensure-parent author =person= :err-if-nil nil)))

(sheeple:defreply sheeple:shared-init :after ((issue =issue=) &key)
  (with-accessors ((fields fields)) issue
    (when fields
      (ensure-parent fields =fields=)
      (ensure-parent (status fields) =status=)
      (ensure-parent (reporter fields) =person= :err-if-nil nil)
      (ensure-parent (creator fields) =person= :err-if-nil nil)
      (ensure-parent (assignee fields) =person= :err-if-nil nil)
      (sheeple:with-properties (comment) fields
        (when comment
          (sheeple:with-properties (comments) comment
            (map 'nil (lambda (comment) (ensure-parent comment =comment=))
                 comments)))))))

(sheeple:defreply show ((person =person=) &rest args)
  (declare (ignore args))
  (format nil "\"~a\" <~a>" (displayname person) (emailaddress person)))

(sheeple:defreply show ((status =status=) &rest args)
  (declare (ignore args))
  (format nil "~a" (name status)))

(defun show-description (description)
  (pprint-logical-block (*standard-output* (mapcar (compose 'tokens 'trim-whitespace)
                                                 (lines description)))
    (pprint-indent :block 4 *standard-output*)
    (pprint-newline :mandatory *standard-output*)
    (loop
      (pprint-exit-if-list-exhausted)
      (let ((line (pprint-pop)))
        (pprint-logical-block (*standard-output* line)
          (loop
            (princ (pprint-pop) *standard-output*)
            (pprint-exit-if-list-exhausted)
            (princ #\space *standard-output*)
            (pprint-indent :block 3)
            (pprint-newline :fill *standard-output*)))
        (pprint-newline :mandatory *standard-output*)))))

(defun show-summary (summary &optional (stream *standard-output*))
  (pprint-logical-block (stream (funcall (compose 'tokens 'trim-whitespace) summary))
    (pprint-indent :block 8 *standard-output*)
    (pprint-exit-if-list-exhausted)
    (format stream "~4tSummary: ")
    (loop
      (princ (pprint-pop) stream)
      (pprint-exit-if-list-exhausted)
      (pprint-newline :fill stream)
      (princ #\space stream))))

(sheeple:defreply show ((issue =issue=) &rest args)
  (declare (ignorable args))
  (with-output-to-string (*standard-output*)
    (when-let ((fields (fields issue)))
      (with-accessors ((status status) (summary summary) (reporter reporter)
                                       (creator creator) (assignee assignee)
                                       (labels fields-labels)) fields

        (format t "~a (~a) <~a>~%"
                (key issue)
                (show status)
                (princ-to-string (puri:merge-uris (format nil "/browse/~a" (key issue))
                                                  *hostname*)))

        (show-summary summary)

        (show-person reporter "Reporter")
        (show-person creator "Creator")
        (when assignee
          (show-person assignee "Assignee"))

        (when (< 0 (length labels))
          (show-labels labels))

        (when (description fields)
          (show-description (description fields))))

      ; The head of the arguments determines whether or not
      ; we show the comments
      (when (and (car args))
        (if-let ((comment (comment fields)))
          (sheeple:with-properties (comments) comment
            (loop for comment across comments
                  do (format t "~&~a:~% ~<   ~@;~{~{~a~^ ~:_~}~2%~}~:>~&"
                             (show (author comment))
                             (list (map 'list #'tokens
                                        (split-sequence #\newline
                                                        (body comment)))))))))

      (fresh-line))))

(sheeple:defproto =project= () (name key issuetypes))

(sheeple:defproto =issuetype= () (description name))

(sheeple:defreply sheeple:shared-init :after ((project =project=) &key)
  (with-accessors ((issuetypes issuetypes)) project
    (when issuetypes
      (map nil
           (lambda (issuetype) (ensure-parent issuetype =issuetype=))
           issuetypes))))

(sheeple:defreply show ((issuetype =issuetype=) &rest arg)
  (declare (ignore args))
  (with-output-to-string (*standard-output*)
    (pprint-logical-block (*standard-output* (tokens (description issuetype)))
      (pprint-indent :block 15 *standard-output*)
      (pprint-exit-if-list-exhausted)
      (format *standard-output* "~4t~10@a: " (name issuetype))
      (loop
        (princ (pprint-pop))
        (pprint-exit-if-list-exhausted)
        (pprint-newline :fill *standard-output*)
        (princ #\space)))))

(sheeple:defreply show ((project =project=) &rest args)
  (declare (ignore args))
  (with-output-to-string (*standard-output*)
    (format t "~a: ~a~%~{~a~&~}" (key project) (name project)
            (map 'list #'show (issuetypes project)))))

(deftype vector-of-objects () '(vector (or hash-table sheeple:object) *))

(defun json2sheeple (json &optional parent)
  (labels
      ((handle-parsed (parsed-json)
         (typecase parsed-json
           (vector-of-objects (map 'vector #'handle-parsed parsed-json))
           (hash-table
            (let ((result (sheeple:object)))
              (loop for json-prop being the hash-keys of parsed-json using (hash-value json-value)
                 do (setf (sheeple:property-value result
                                                  (intern (string-upcase json-prop) :jira-api))
                          (typecase json-value
                            (hash-table (handle-parsed json-value))
                            (vector-of-objects (map 'vector #'handle-parsed json-value))
                            (t json-value)))
                 finally (return result))))
           (t parsed-json))))
    (let* ((yason:*parse-json-arrays-as-vectors* t)
           (result (handle-parsed (yason:parse json))))
      (when parent
        (ensure-parent result parent))
      result)))