;; MIT license Edward Langley (c) 2018
 

 (defpackage :daydreamer.main

   (:use :cl :fw.lu :alexandria :daydreamer.aws-result)

   (:export main dump
            #:stack-parameters
            #:stack-outputs
            #:stack-for-name

            #:watch-stack
            #:stack-info))

 (in-package :daydreamer.main)

 
 (define-condition invalid-result (error)
   ())
 
 (defun stack-for-name (name)
   (let* ((aws-result (car (extract-list (cdar (aws/cloudformation:describe-stacks :stack-name name)))))
          (the-stack (extract-stack aws-result)))
     the-stack))
 

 (defun print-kvs (prefix formatter stream data)
   (let ((key-key (format nil "~aKey" prefix))
         (value-key (format nil "~aValue" prefix)))
     (mapcar (lambda (inp)
               (let ((k (cadr (assoc key-key inp :test #'equal)))
                     (v (cadr (assoc value-key inp :test #'equal))))

                 (format stream formatter k v)))

             data)))

 
 (defun stack-outputs (the-stack)

   (print-kvs "Output"
              (tagged-kv-formatter "OUTPUT") t

              (outputs the-stack)))
 
 (defun stack-parameters (the-stack)

   (print-kvs "Parameter"

              (tagged-kv-formatter "PARAMETER") t

              (parameters the-stack)))
 

 (defun lt-format (a b &key &allow-other-keys)
   (local-time:format-timestring a b))

 (defgeneric duration-of (timeline)
   (:method ((timeline timeline))
     (local-time-duration:timestamp-difference (end-date-time timeline)
                                               (start-date-time timeline))))

 (defun every-five-seconds (cb args &optional (delay-function #'sleep))
   (loop

     for (continue? . next-args) = (multiple-value-list (apply cb args)) then (multiple-value-list (apply cb next-args))
     while continue?
     do (funcall delay-function 5)))

 #+(or)

 (deftest every-five-seconds ()
   (let ((counter 0)
         delay)
     (flet ((fake-delay (num)
              (incf counter)
              (setf delay num))
            (work ()
              (< counter 10)))
       (every-five-seconds #'work () #'fake-delay)
       (should be = 10 counter)

       (should be = 5 delay)))
 
   (let (delay
         (count 0)
         (counters ()))
     (flet ((fake-delay (num)
              (setf delay num))
            (work (counter)
              ;; temporary for initial red...
              (if (> count 10)
                  (throw 'quit nil)
                  (incf count))
 
              (push counter counters)
              (values (< counter 10)
                      (1+ counter))))
       (catch 'quit
         (every-five-seconds #'work '(0) #'fake-delay))
       (should be equal
               (alexandria:iota 11 :start 10 :step -1)
               counters)

       (should be = 5 delay))))
 

 (defun resource-block (the-stack)
   (format t "~& RESOURCES ~%============~%")
   (let ((resources (daydreamer.aws-result:extract-list
                     (serapeum:assocdr "StackResources"
                                       (aws/cloudformation:describe-stack-resources
                                        :stack-name (stack-name the-stack))
                                       :test 'equal)
                     'daydreamer.aws-result:extract-stack-resource)))
     (loop for resource in resources
           do (format t "RESOURCE ~a (~a) ~a ~a~:[~;~%~:*~4t~a~]~%"
                      (logical-resource-id resource)
                      (resource-type resource)
                      (resource-status resource)
                      (physical-resource-id resource)
                      (resource-status-reason resource))))
   (format t "~&============~2%"))
 

 (defun parameter-block (the-stack)
   (format t "~& PARAMETERS ~%============~%")
   (stack-parameters the-stack)
   (format t "~&============~2%"))
 
 (defun output-block (the-stack)
   (format t "~2& OUTPUTS ~%=========~%")
   (stack-outputs the-stack)
   (format t "~&=========~%")
   (values))
 

 (defclass stack-formatter ()
   ((%stack :initarg :stack :accessor stack)
    (%old-status :initarg :old-status :accessor old-status :initform nil)))
 

 (defmethod stack-name ((stack-formatter stack-formatter))
   (when (slot-boundp stack-formatter '%stack)
     (stack-status (stack stack-formatter))))
 

 (defmethod stack-status ((stack-formatter stack-formatter))
   (when (slot-boundp stack-formatter '%stack)
     (stack-status (stack stack-formatter))))
 
 (defmethod parameters ((stack-formatter stack-formatter))
   (when (slot-boundp stack-formatter '%stack)
     (parameters (stack stack-formatter))))
 
 (defmethod outputs ((stack-formatter stack-formatter))
   (when (slot-boundp stack-formatter '%stack)
     (outputs (stack stack-formatter))))
 
 (defmethod (setf stack) :before (new-value (object stack-formatter))
   (setf (old-status object) (stack-status object)))
 

 (defgeneric refresh (stack-formatter)

   (:method ((stack daydreamer.aws-result:stack))

     (stack-for-name (stack-name stack)))

   (:method ((stack-formatter string))
     (make-instance 'stack-formatter :stack (stack-for-name stack-formatter)))
   (:method ((stack-formatter stack-formatter))

     (setf (stack stack-formatter) (refresh (stack stack-formatter)))

     stack-formatter))
 

 (defmethod old-status ((stack daydreamer.aws-result:stack))

   nil)
 

 (defun stack-info (the-stack status parameters outputs &optional (resources nil))

   (with-accessors ((old-status old-status)) the-stack
     (let* ((current-status (stack-status the-stack)))
       (unless old-status

         (when parameters
           (parameter-block the-stack)))

 
       (unless (equal old-status current-status)

         (when status
           (format t "~&STATUS ~a~%" current-status)))
 
       (when resources
         (terpri)
         (resource-block the-stack))

 
       (if (ends-with-subseq "COMPLETE" (symbol-name current-status))

           (when outputs
             (output-block the-stack))

           t))))

 (defmacro refreshing (cb &rest args)

   `(lambda (thing)
      (let ((refreshed-thing (refresh thing)))

        (values (,cb refreshed-thing ,@args)

                refreshed-thing))))

 (defun watch-stack (name)

   (format t "~&Watching ~s~2%" name)

   (every-five-seconds (refreshing stack-info t t t)

                       (list name))

   (fresh-line))