(in-package :araneus.routes)

(defgeneric resolve-route (url method content-type &key headers)
  (:documentation "The most generic method for resolving a route.
                   
                   Specialize with a keyword eql-specializer for method or content-type
                   to define a particular understanding of either"))

(defgeneric match-token (url token)
  (:documentation "Match a url against a given token."))

(defclass match-tree ()
  ((-token :initarg :token :accessor token)
   (-children :accessor children :initform (make-array 5 :adjustable t :fill-pointer 0))
   (-name :initarg :name :accessor name :initform nil)))



(defun token= (tok1 tok2)
  (if (typep tok1 'match-tree)
    (setf tok1 (token tok1)))

  (if (typep tok2 'match-tree)
    (setf tok2 (token tok2)))

  (equal tok1 tok2))

(defgeneric add-to-tree (match-tree token)
  (:method ((match-tree match-tree) (tokens list))
    (loop with current = match-tree
          for token in tokens
          do (setf current (add-to-tree current token))))

  (:method ((match-tree match-tree) (token integer))
   (with-accessors ((children children)) match-tree
     (if (eql (token match-tree) token)
       match-tree
       (prog1 (elt children
                   (or (position token (children match-tree) :test #'token=)
                       (vector-push-extend (make-instance 'match-tree :token token)
                                           children)))
         (setf children (stable-sort children #'< :key #'token)))))))

(define-modify-macro orf (it) or)

(defgeneric match-match-tree (match-tree item)
  (:method ((match-tree match-tree) (tokens list))
    (let ((current match-tree))
      (dolist (token tokens current)
        (let ((next (match-match-tree current token)))
          (setf current next)))
      ))
  (:method ((match-tree match-tree) (token integer))
    (find token
          (children match-tree)
          :test #'token=)))

(defun random-match-tree (&optional (iters 10))
  (flet ((random-list (len lim) (loop repeat len collect (1+ (random lim)))))
    (let ((result (make-instance 'match-tree :token nil)))
      (loop repeat iters
            do (add-to-tree result
                            (random-list (1+ (random 5)) (1+ (random 10))))
            finally (return result)))))

(defun print-match-tree (match-tree &optional (level 0))
  (format t "~&~v,2,1,'-<~>~a~%" level (token match-tree))
  (loop for child across (children match-tree)
        do (print-match-tree child (1+ level))))

(coalesce-lists
  (coalesce-lists '(1 2 3) '(1 2 3 4))
  (coalesce-lists '(1 2 4) '(1 3 4)))
; => '(1 (2 3) (3 4))

(defun match-url)