(in-package #:tempores)

(defclass status-calculator ()
  ((rate :initarg :rate :accessor rate)
   (total-hours :initform 0 :initarg :total-hours :accessor total-hours)
   (client-totals :initarg :client-totals :accessor client-totals :initform (make-hash-table :test 'equalp))))

(defclass report ()
  ((status-calculator :initarg :status-calculator :accessor status-calculator)
   (status-lines :initform nil :accessor :status-lines)
   (entries :initform nil :accessor :entries)))

(defun make-status-calculator (rate)
  (make-instance 'status-calculator :rate rate))

(defclass status-line ()
  ((client :initarg :client :accessor client)
   (duration :initarg :duration :accessor duration :initform 0)))

(defclass parsed-entry ()
  ((date :initarg :date :accessor date)
   (client :initarg :client :accessor client)
   (memo :initarg :memo :accessor memo)))

(defclass complete-entry (parsed-entry)
  ((duration :initarg :duration :accessor duration)))

(defclass partial-entry (parsed-entry)
  ((start-times :initarg :start-times :initform nil :accessor start-times)))

(define-condition autocorrect-warning (warning)
  ((old-value :initarg :old-value :accessor old-value)
   (new-value :initarg :new-value :accessor new-value))
  (:report (lambda (condition stream)
             (with-slots (old-value new-value) condition
               (format stream "Automatic correction made: ~s -> ~s" old-value new-value)))))

(define-condition incomplete-entry-warning (warning) ()
  (:report (lambda (condition stream)
             (declare (ignore condition))
             (format stream "Incomplete Entry Found"))))

(define-condition parsing-error ()
  ((leftovers :initarg :leftovers :accessor leftovers))
  (:report (lambda (condition stream)
               (format stream "Parse error: ~20s leftover" (leftovers condition)))))

(defgeneric total-line (calc rate)
  (:method ((calc status-calculator) rate)
   (with-accessors ((total-hours total-hours)) calc
     (format nil "~26<Total~>:~7,2F hours @ ~7,2F $/hr = $~7,2F"
             total-hours rate (* rate total-hours)))))

(defgeneric calculate-cost (calc time)
  (:method ((calc status-calculator) (status-line status-line))
   (* (rate calc) (duration status-line))))

#|
(define-message print-partial-line (client memo duration starts)
  )
|# 

(defgeneric print-entries (entries)
  (:method ((entries list))
   (mapcar #'print-entries entries))
  (:method ((entry partial-entry))
   (format t "~&~4<~>~a, ~a (currently ~3,2f hours):~%~{~12<~>one starting at ~a~%~}"
           (client entry)
           (memo entry)
           (handler-bind ((incomplete-entry-warning (lambda (c) c (invoke-restart 'duration-to-now))))
             (calculate-duration-in-15mins (duration entry)))
           (mapcar
             (alambda (list (local-time:format-timestring
                              nil it
                              :format '(:year #\/ (:month 2) #\/ (:day 2) #\Space
                                        (:hour 2) #\: (:min 2) #\: (:sec 2)))))
             (start-times entry))))
  (:method ((it complete-entry))
   (format t "~&~4a ~10<~:(~a~)~> ~7,2F hrs ~a~%"
           (date it) (client it) (duration it) (memo it))))

(defgeneric record-client (calc client hours)
  (:method ((calc status-calculator) client hours)
    (let ((client (make-keyword (string-upcase client))))
      (incf (gethash client (clients calc) 0)
            hours))))

(defgeneric update (calculator entry)
  (:method ((calculator status-calculator) entry)
   (incf (total-hours calculator) (duration entry)))
  (:method ((calculator status-line) entry)
   (incf (duration calculator) (duration entry))))


(defmethod duration ((obj partial-entry))
  (restart-case
    (progn (warn 'incomplete-entry-warning)
           (local-time-duration:duration)) 
    (zero-duration () (local-time-duration:duration))
    (duration-to-now ()
      (let ((now (local-time:now)))
        (local-time-duration:timestamp-difference
          now
          (extremum (start-times obj) #'local-time-duration:duration>
                    :key (alambda (local-time-duration:timestamp-difference now it))))))))

(defun make-complete-entry (date client memo duration)
  (make-instance 'complete-entry
                 :date date
                 :client client
                 :memo memo
                 :duration duration))

(defun make-partial-entry (date client memo start-times)
  (make-instance 'partial-entry
                 :date date
                 :client client
                 :memo memo
                 :start-times start-times))