;;;; jira-api.lisp
(in-package #:jira-api)

(defun get-filter (auth filter &rest r &key (expand "subscriptions[:-5]"))
  (declare (ignore expand))
  (apply 'api-get-call auth (format nil "filter/~d" filter) r))

(defun get-issues (auth &key jql)
  (if jql
      (api-get-call auth "search" "jql" jql)
      (api-get-call auth "search")))

(defmacro jql (auth &body jql)
  `(api-get-call ,auth "search" "jql"
                 ,(apply #'serapeum:concat jql)))

(defun run-filter (auth filter)
  (let ((jql (gethash "jql" (yason:parse (get-filter auth filter)))))
    (get-issues auth :jql jql)))

(defun get-issue (auth key &rest params &key expand)
  (declare (ignore expand))
  (apply 'api-get-call auth (format nil "issue/~a" key) params))

(defun get-board-issues (auth key &rest params &key expand)
  (declare (ignore expand))
  (apply 'api-get-call auth (format nil "board/~a/issue" key) params))

(defun get-projects (auth)
  (api-get-call auth "issue/createmeta"))

(defun make-issue (project-key summary &key (description nil description-p) (issue-type "Bug"))
  (let* ((issue (make-hash-table :test 'equal))
         (project (alist-string-hash-table `(("key" . ,project-key))))
         (issue-type (alist-string-hash-table `(("name" . ,issue-type)))))
    (setf (gethash "fields" issue)
          (alist-string-hash-table
            `(("project" . ,project)
              ("summary" . ,summary)
              ,@(when description-p
                  (list
                    (cons "description" description)))
              ("issuetype" . ,issue-type))))
    issue))

(defun post-issue (auth issue)
  (let-each (:be *)
    issue
    (with-output-to-string (s)
      (yason:encode * s))
    (api-post-call auth "issue" *)))

(defun post-issue-from-fields (auth project-key summary &key
                        (description nil description-p)
                        (issue-type nil issue-type-p))
  (let ((optional-arguments '()))
    (when issue-type-p
      (push issue-type optional-arguments))
    (when description-p
      (push description optional-arguments))

    (let-each (:be *)
      (apply #'make-issue project-key summary optional-arguments)
      (post-issue auth *))))

(defun read-issue (&optional (iostream *query-io*))
  (let ((project-key (prompt :project-key iostream))
        (summary (prompt :summary iostream))
        (description (optional-prompt iostream :description "Add a description? ")))
    (apply #'make-issue project-key summary
           (list*
             (when description
               (list description))))))

(defun show-person (person title)
  (format t "~&~4t~a: ~a~%" title (show person)))

(defun show-labels (labels)
  (format t "~&~4tLabels: ~{~a~}~%" (coerce labels 'list)))

(defun classify-issues (sheeple-issues &optional (classify-by '(status name)))
  (sheeple:with-properties (issues) sheeple-issues
    (loop with classes = (make-hash-table :test 'equalp)
          for issue across issues
          do (ensure-parent issue =issue=)
          do (loop for classification in classify-by
                   for thing = (sheeple:property-value (fields issue) classification)
                       then (sheeple:property-value thing classification)
                   finally (push issue (gethash thing classes)))
          finally (return classes))))

(defun status-to-num (status)
  (string-case (string-downcase status)
    ("open" 0)
    ("in progress" 1)
    ("needs qr" 2)
    ("needs demo" 3)
    ("closed" 4)
    (t 5)))

(defun sort-issues-by-status (sheeple-issues)
  (prog1 sheeple-issues
    (sheeple:with-properties (issues) sheeple-issues
      (setf issues
            (sort issues #'< :key (op (status-to-num (name (status (fields _))))))))))

(defun show-issue-short (issue &optional (stream t))
  (sheeple:with-properties (key self) issue
    (let* ((fields (fields issue))
           (status (name (status fields)))
           (summary (summary fields)))

      (format stream "~&~a (~a) <~a>~%"
              key
              status 
              (puri:merge-uris (format nil "/browse/~a" (key issue))
                               *hostname*))

      (show-summary summary stream)
      (fresh-line stream))))

(defun map-issues (fun sheeple-issues)
  (sheeple:with-properties (issues) sheeple-issues
    (loop for issue across issues
          do (ensure-parent issue =issue=)
          collect (funcall fun issue))))

(defun show-issues (sheeple-issues)
  (sheeple:with-properties (issues) sheeple-issues
    (loop for issue across issues
          do (ensure-parent issue =issue=)
          do (show-issue-short issue))))

(defun print-on-own-line (str)
  (format t "~&~a~&" str))

(defun show-projects (projects)
  (sheeple:with-properties (projects) projects
    (loop for project across projects
          do (ensure-parent project =project=)
          do (print-on-own-line (show project)))))

(defun get-points-for-issues (count start)
  (loop with end = (+ count start)
     for batch-start from start to end by 50
     for batch-count = (min (- end batch-start)
                            50)
     append (map 'list #'points
                 (issues
                  (json2sheeple
                   (get-issues *auth* :jql
                               (format nil "issueKey in (~{CJPM-~a~^, ~})"
                                       (alexandria:iota batch-count
                                                        :start batch-start)))
                   =issues=)))))