(in-package :fwoar.cl-git)

(defclass git-tree (git-object)
  ((%entries :initarg :entries :reader entries)))

(defun git-tree (entries)
  (fw.lu:new 'git-tree entries))

(defclass tree-entry (git-object)
  ((%repo :initarg :repo :reader repository)
   (%mode :initarg :mode :reader te-mode)
   (%name :initarg :name :reader te-name)))

(defun tree-entry (repo name mode hash)
  (fw.lu:new 'tree-entry repo name mode hash))

(defmethod print-object ((o tree-entry) s)
  (if *print-readably*
      (format s "#.(~s ~s ~s ~s)"
              'tree-entry
              (te-name o)
              (te-mode o)
              (hash o))
      (print-unreadable-object (o s :type t :identity t)
        (format s "(~a: ~a)"
                (te-name o)
                (subseq (hash o) 0 8)))))

(defun parse-tree-entry (data)
  (values-list (partition 0 data :with-offset 20)))

(defun format-tree-entry (repo entry)
  (destructuring-bind (info sha) (partition 0 entry)
    (destructuring-bind (mode name)
        (partition #\space
                   (babel:octets-to-string info :encoding *git-encoding*))
      (tree-entry repo name mode (elt (->sha-string sha) 0)))))

(defun tree-entries (repo data &optional accum)
  (if (<= (length data) 0)
      (nreverse accum)
      (multiple-value-bind (next rest) (parse-tree-entry data)
        (tree-entries repo
                      rest
                      (list* (format-tree-entry repo next)
                             accum)))))

(defmethod -extract-object-of-type ((type (eql :tree)) s repository &key)
  (git-tree (tree-entries repository s)))

(defmethod component ((component (eql :entries)) (object git-tree))
  (entries object))
(defmethod component ((component string) (object git-tree))
  (car (remove component (entries object)
               :test-not #'equal
               :key 'te-name)))
(defmethod component ((component pathname) (object git-tree))
  (remove-if-not (lambda (it)
                   (pathname-match-p it component))
                 (entries object)
                 :key 'te-name))

(defmethod component ((component (eql :name)) (object tree-entry))
  (te-name object))
(defmethod component ((component (eql :mode)) (object tree-entry))
  (te-mode object))
(defmethod component ((component (eql :ref)) (object tree-entry))
  (ref (repository object)
       (hash object)))