;;; taskrunner-java.el --- Provide functions to retrieve java build system targets -*- lexical-binding: t; -*-
;; Copyright (C) 2019 Yavor Konstantinov

;;;; Commentary:
;; Provide function for extracting java build system targets.
;; Support included for:
;; - Ant
;; - Gradle

;;;; Code:
(require 'cl-lib)
(require 'subr-x)

;;;; Variables

(defcustom taskrunner-gradle-heading-regexps
  '("Build tasks\n-+\n"
    "Help tasks\n-+\n"
    "Verification tasks\n-+\n"
    "Documentation tasks\n-+\n"
    "Distribution tasks\n-+\n"
    "Other tasks\n-+\n"
    "Build Setup tasks\n-+\n"
    "IDE tasks tasks\n-+\n"
    )
  "Regular expressions used to locate task section headings from gradle output."
  :type 'list
  :group 'taskrunner)

;;;; Functions
;; These are here just to silence the bytecompiler. They are defined in
;; `taskrunner.el' and will be loaded later on but due to these files being
;; required before the function being loaded, a warning is emitted.
(declare-function taskrunner--narrow-to-line "ext:taskrunner")
(declare-function taskrunner--make-task-buff-name "ext:taskrunner")

;; Each block contains several tasks which can be executed.
;; The block has the following form:
;; TASK-HEADING
;; ------------ (underline for the heading)
;; task 1
;; task 2
;; ...
;; task n-1
;; task n
;; BLANK-LINE
;; This function narrows to the region which starts directly after the underline
;; for the heading and ends at the blank line separating each block.
(defun taskrunner--retrieve-gradle-heading-tasks (heading)
  "Retrieve the gradle tasks below the heading HEADING and return as list."
  (widen)
  (goto-char (point-min))
  (let ((beg (re-search-forward heading nil t)))
    (when beg
      (narrow-to-region beg
                        (progn
                          (re-search-forward "^$" nil t)
                          ;; Go up a line so the empty line at the end of the block
                          ;; is not included in the output
                          (forward-line -1)
                          (line-end-position)))

      (cl-map 'list (lambda (elem)
                      (concat "GRADLE" " " (car (split-string elem " "))))
              (split-string (buffer-string) "\n")))))

(defun taskrunner-get-gradle-tasks (dir)
  "Retrieve the gradle tasks for the project in directory DIR.
This function returns a list of the form:
\(\"GRADLE TASK1\" \"GRADLE TASK2\"...)"
  (let ((default-directory dir)
        (gradle-tasks '()))
    (call-process "gradle"  nil (taskrunner--make-task-buff-name "gradle")  nil "tasks")
    (with-temp-buffer
      (set-buffer (taskrunner--make-task-buff-name "gradle"))
      (dolist (curr-regex taskrunner-gradle-heading-regexps)
        (let ((tasks-retrieved (taskrunner--retrieve-gradle-heading-tasks curr-regex)))
          (when tasks-retrieved
            (setq gradle-tasks (append gradle-tasks tasks-retrieved))
            )))
      (kill-current-buffer))
    ;; Return the tasks acquired
    gradle-tasks))

;; In general, the output of 'ant -verbose -p' looks like this:
;; some-java-logging-commands...
;; ...
;; Main targets:
;;
;; main_target1 comment
;; ...
;; main_targetN comment
;; Other targets:
;;
;; other_target1
;; ...
;; other_targetN
;; Sometimes the buffer might end with 'Default target:' and sometimes
;; it might not if there is no default target assigned for project
(defun taskrunner--retrieve-ant-tasks-from-buffer ()
  "Retrieve all and tasks from the current buffer.
This function is meant to be used with the output of `ant -verbose -p'.
If you need to retrieve tasks from ant, use the function
`taskrunner-get-ant-tasks' instead of this."
  (goto-char (point-min))
  (let ((beg (search-forward-regexp "Main targets:\n\n" nil t))
        (ant-tasks '()))
    (when beg
      (narrow-to-region (point-at-bol)
                        (progn
                          (search-forward-regexp "Other targets:")
                          (forward-line -1)
                          (point-at-eol)))
      (cl-map 'list (lambda (elem)
                      (if (not (string-equal elem ""))
                          (push (concat "ANT" " "  (car (split-string (string-trim elem) " "))) ant-tasks)
                        ))
              (split-string (buffer-string) "\n"))
      (widen))

    ;; Look for the 'Other targets' section
    (goto-char (point-min))
    (setq beg (search-forward-regexp "Other targets:\n\n" nil t))
    ;; If the section exists, retrieve the tasks in it.
    (when beg
      (narrow-to-region (point-at-bol)
                        ;; If the ant project has a default target then the last
                        ;; line of the output starts with 'Default target'
                        ;; which is not a task which can be ran but information.
                        ;; Otherwise, the last line is a task
                        (if (search-forward-regexp "Default target:" nil t)
                            (progn
                              (forward-line -1)
                              (point-at-eol))
                          (progn
                            (goto-char (point-max))
                            (point-at-eol))
                          ))
      (cl-map 'list (lambda (elem)
                      (if (not (string-equal elem ""))
                          (push (concat "ANT" " "  (car (split-string (string-trim elem) " "))) ant-tasks)))
              (split-string (buffer-string) "\n")))
    (kill-current-buffer)

    ;; Return the tasks after killing buffer
    ant-tasks))

(defun taskrunner-get-ant-tasks (DIR)
  "Retrieve the ant tasks for the project in directory DIR.
This function returns a list of the form:
\(\"ANT TASK1\" \"ANT TASK2\"...)"
  (let ((default-directory DIR))
    (call-process "ant"  nil (taskrunner--make-task-buff-name "ant")  nil "-verbose" "-p")
    (with-temp-buffer
      (set-buffer (taskrunner--make-task-buff-name "ant"))
      (taskrunner--retrieve-ant-tasks-from-buffer))))

(provide 'taskrunner-java)
;;; taskrunner-java.el ends here