(defpackage :3dr.bisorter
   (:use :alexandria :serapeum :cl))
 
 (in-package :3dr.bisorter)
 
 (defun make-adj-arr (&optional (size 25))
   (make-array size :adjustable t :fill-pointer 0))
 
 (defclass bilayer ()
   ((fg :initarg :fg :accessor fg :initform (make-adj-arr))
    (bg :initarg :bg :accessor bg :initform (make-adj-arr))
    (dimension :initarg :dimension :accessor dimension)
    (center :initarg :center :accessor center)))
 
 (defun split-points (points bilayer)
   (with-slots (fg bg dimension center) bilayer
     (map nil
          (lambda (point)
            (if (< (elt center dimension) (elt point dimension))
              (vector-push-extend point fg)
              (vector-push-extend point bg)))
          points)
     bilayer))
 
 (defmethod print-object ((object bilayer) s)
   (print-unreadable-object (object s :type t :identity t)
     (with-slots (fg bg dimension center) object
       (format s "center: ~s div on: ~s (~d fg, ~d bg)"
               center dimension
               (length fg)
               (length bg)))))
 
 (defun split-bilayer (bilayer)
   (with-slots (fg bg dimension center) bilayer
     (let* ((new-dimension (mod (1+ dimension)
                                (length center)))
            (new-fg-bilayer (make-instance 'bilayer
                                        :dimension new-dimension
                                        :center center))
            (new-bg-bilayer (make-instance 'bilayer
                                        :dimension new-dimension
                                        :center center)))
       (list (split-points fg new-fg-bilayer)
             (split-points bg new-bg-bilayer)))))
 
 (defvar *bis*)
 (defvar *points*)
 
 (defun main ()
   (setf *bis* (make-instance 'bilayer
                              :dimension 0
                              :center (vector 0 0 0)))
 
   (flet ((100- (x) (- 100 x)))
     (setf *points*
           (loop repeat 1000
                 collect (vector (random 200)
                                 (100- (random 200))
                                 (100- (random 200))))))
 
   (split-points *points* *bis*))