(defpackage :git-pick-patch
  (:use :cl :alexandria :serapeum)
  (:export ))
(in-package :git-pick-patch)

(defun read-header (inp)
  (string-join (loop for line = (read-line inp nil)
                  while line
                  collect line
                  until (eql #\@ (peek-char nil inp nil)))
               #\newline))

(defun read-hunk (inp)
  (when (eql #\@
             (peek-char nil inp nil))
    (string-join (loop for line = (read-line inp nil)
                    while line
                    collect line
                    until (member (peek-char nil inp nil) '(#\@ #\d)))
                 #\newline)))

(defun read-hunks (inp)
  (loop for hunk = (read-hunk inp)
     while hunk
     collect hunk))

(defun get-file-patch (inp)
  (list (read-header inp)
        (read-hunks inp)))

(defun get-all-patches (inp)
  (loop for patch = (get-file-patch inp)
     for (header data) = patch
     while (and (string/= header "")
                (not (null data)))
     collect patch))

(defun filter-hunks (hunks predicate)
  (remove-if-not predicate hunks))

(defun filter-file-hunks (file-data predicate)
  (let ((results (filter-hunks (cadr file-data)
                               predicate)))
    (when results
      (list (car file-data)
            results))))

(defun filter-patch (patch-data predicate)
  (remove-if #'null (mapcar (lambda (x)
                              (filter-file-hunks x predicate))
                            patch-data)))

(defun combine-hunks (hunks)
  (string-join hunks #\newline))

(defun rebuild-file-patch (file-data)
  (destructuring-bind (header hunks) file-data
    (format nil "~a~%~a" header (combine-hunks hunks))))

(defun rebuild-patch (patch-data)
  (string-join (mapcar #'rebuild-file-patch patch-data)
               #\newline))

(defun main ()
  (if (null (cadr sb-ext:*posix-argv*))
      (format t "~&Must provide a pattern!")
      (let* ((pattern (cadr sb-ext:*posix-argv*)))
        (loop for patch = (get-file-patch *standard-input*)
           for filtered = (when patch (filter-file-hunks patch
                                                         (op (cl-ppcre:scan pattern _))))
           until (equal patch '("" nil))
           when filtered do
             (format t "~&~a~&" (rebuild-file-patch filtered))))))