(in-package :collection-class)

(defclass collection (standard-object #+sbcl sequence)
  ())

(define-condition value-error ()
  ((value :initarg :value :accessor value)))

(defgeneric push-item (item collection)
  (:documentation "Push item onto the beginning of the collection"))

(defgeneric items (collection)
  (:documentation "Get the items from a collection"))

(defgeneric duplicate-collection (collection))

(defgeneric copy-instance (object &rest initargs &key &allow-other-keys)
  (:documentation "Makes and returns a shallow copy of OBJECT.

                   An uninitialized object of the same class as OBJECT is allocated by
                   calling ALLOCATE-INSTANCE.  For all slots returned by
                   CLASS-SLOTS, the returned object has the
                   same slot values and slot-unbound status as OBJECT.

                   REINITIALIZE-INSTANCE is called to update the copy with INITARGS.")
  (:method ((object standard-object) &rest initargs &key &allow-other-keys)
   (let* ((class (class-of object))
          (copy (allocate-instance class)))
     (dolist (slot-name (mapcar #'closer-mop:slot-definition-name (closer-mop:class-slots class)))
       (when (slot-boundp object slot-name)
         (setf (slot-value copy slot-name)
               (slot-value object slot-name))))
     (apply #'reinitialize-instance copy initargs))))


; TODO: actually use item-class...
; TODO: finish initform handling.  Have to figure out how to make initform work with push-item
(defmacro define-collection ((name item-class &key (initarg :items) (initform '(list))) (&rest supers) &body ((&rest slots) &rest other-stuff))
  (with-gensyms (item-slot-sym)
    `(progn (defclass ,name (,@supers collection)
              ((,item-slot-sym :initarg ,initarg :initform ,initform :accessor items) ;
               ,@slots)
              ,@other-stuff)
            (defmethod duplicate-collection ((collection ,name))
              (let ((result (copy-instance collection)))
                (setf (items result)
                      (copy-seq (items result)))
                result))
            (defmethod push-item ((item ,item-class) (collection ,name))
              (push item (items collection))))))

(defmethod random-item ((collection collection) &optional (random-state *random-state*))
  (let* ((length (length (items collection)))
         (selected-index (random length random-state)))
    (elt (items collection)
         selected-index)))

(defmethod nth-item ((collection collection) (index integer))
  (if (>= index 0)
    (elt (items collection) index)
    (error 'value-error :value index)))