(in-package :fwoar.event-loop)
 
 (defgeneric run (task event-loop)
   (:method :around (task event-loop)
     (bb:with-promise (resolve reject)
       (enqueue (queue event-loop)
                (lambda ()
                  (handler-case (resolve (call-next-method))
                    (serious-condition (c)
                      (reject c))))))))
 
 
 (defgeneric enqueue (queue fn))
 
 (defgeneric prepare-loop (event-loop)
   (:method (event-loop)
     (declare (ignore event-loop))))
 

 (defgeneric cleanup (event-loop)
   (:method (event-loop)
     (declare (ignore event-loop))))
 

 (defgeneric queue (event-loop))
 

 (defgeneric (setf finish-cb) (cb event-loop))
 (defgeneric finish-cb (event-loop))

 (defgeneric tick (event-loop)
   (:method :around (event-loop)
     (call-next-method)))

 
 (defparameter *task-depth* 10)
 

 (defmacro until-finished (finished-var &body body)
   `(loop until ,finished-var do
          ,@body))
 

 (defun run-loop (event-loop)
   (let ((finished nil))

     (setf (finish-cb event-loop)
           (lambda ()
             (setf finished t)))

     (prepare-loop event-loop)

     (unwind-protect (until-finished finished

                       (with-simple-restart (continue "continue event loop")
                         (tick event-loop)))
       (format t "unwinding...")

       (cleanup event-loop))))

 
 (defun wait-for-promise (promise)
   (let* ((result-queue (make-instance 'chanl:bounded-channel)))
     (bb:alet ((v promise))
       (chanl:send result-queue v))
     (loop
       (return (chanl:recv result-queue)))))