(in-package :cl-user)
 
 (defmacro quickloads (&rest r)
   `(progn
      ,@(loop for x in r
              collect `(ql:quickload ,x))))
 
 (quickloads
   :cl-actors
   :cells
   :contextl)
 
 (defpackage :math-test
   (:use :cl :cl-actors :cells))
 
 (in-package :math-test)
 
 (defmacro push-many (place &body items)
   `(progn ,@(loop for item in items
                   collect `(push ,item ,place))))
 
 (defmodel service-rating ()
           ((rating :cell t :accessor rating :initarg :rating :initform (c-in :normal))
            (rate   :cell t :accessor rate   :initform (c? (case (rating self)
                                                             (:normal 0.18)
                                                             (:excellent 0.25)
                                                             (:poor 0.15))))))
 
 (defmodel tip-calc ()
           ((cost :cell t :accessor cost :initarg :cost :initform (c-in 0))
            (rate :cell t :accessor rate :initarg :rate :initform (c-in 0.18))
            (tip  :cell t :accessor tip  :initform (c? (* (cost self)
                                                          (rate self))))))
 
 (defmodel item ()
           ((kind :cell t :accessor kind :initarg :kind :initform (c-in :food))
            (cost :cell t :accessor cost :initarg :cost :initform (c-in 0))))
 
 (defmodel bill ()
           ((items :accessor items :initarg :items :initform (c-in nil))
            (cost  :accessor cost  :initform (c? (apply #'+
                                                        (loop for item in (items self)
                                                              collect (cost item)))))))
 
 (defmodel meal-expense-calculator ()
           ((subtotal :accessor subtotal :initarg :subtotal :initform (c-in 0))
            (tax-rate :accessor tax-rate :initarg :tax-rate :initform (c-in 0.08))
            (tip      :accessor tip      :initarg :tip      :initform (c-in 0))
            (total    :accessor total    :initform (c? (+   (subtotal self)     
                                                            (* (tax-rate self)
                                                               (subtotal self))
                                                            (tip self))))))
 
 #|
  |(defobserver tip ((self tip-calc))
  |             (when old-value-boundp
  |               (format t "The tip is: ~a~%It changed by: ~a~%" new-value (- new-value
  |                                                                            old-value))))
  |
  |#
 
 (defun main (&rest r)
   (let* ((s-r (make-instance 'service-rating))
          (bill (make-instance 'bill))
          (tc (make-instance 'tip-calc :cost (c? (cost bill)) :rate (c? (rate s-r))))
          (meal-calc (make-instance 'meal-expense-calculator
                                    :subtotal (c? (cost bill))
                                    :tip      (c? (tip tc)))))
 
     (push-many (items bill)
                (make-instance 'item :kind :meatloaf :cost 12.99)
                (make-instance 'item :kind :salmon :cost 14.99)
                (make-instance 'item :kind :frenchfries :cost 3.99)
                (make-instance 'item :kind :tomatosoup :cost 3.99)
                (make-instance 'item :kind :burgundy :cost 8.99)
                (make-instance 'item :kind :icedtea :cost 3.99))
     (setf (rating s-r) :excellent)
 
     (format t "~{~a~20t~a~%~}------------------------------~%Subtotal:~20t~a~%Tax:~20t~a~%Tip:~20t~a~%Total:~20t~a~%"
             (loop for item in (items bill)
                   append (list (kind item) (cost item)))
             (subtotal meal-calc)
             (* 0.08 (subtotal meal-calc))
             (tip tc)
             (total meal-calc))))