(defpackage :mfa-tool.stack-store
   (:use :cl)
   (:export #:stack-store #:available-stacks selected-stack parameters outputs))
 (in-package :mfa-tool.stack-store)
 
 (defun column (key)
   (serapeum:op (serapeum:assocadr key _
                                   :test 'equal)))
 
 (defclass stack-store (mfa-tool.store:store mfa-tool.aws-dispatcher:aws-dispatcher)
   ((%available-stacks :accessor available-stacks :initform nil)
    (%selected-stack :accessor selected-stack :initform nil)
    (%parameters :accessor parameters :initform nil)
    (%outputs :accessor outputs :initform nil)))
 
 
 (defun output-columns (output)
   (funcall (data-lens:juxt (column "OutputKey")
                            (column "OutputValue"))
            output))
 
 (defun parameter-columns (output)
   (funcall (data-lens:juxt (column "ParameterKey")
                            (column "ParameterValue"))
            output))
 

 (defmethod mfa-tool.store:dispatch :after ((store stack-store)
                                            (action (eql :refresh)))
   (mfa-tool.store:dispatch store
                            (mfa-tool.aws-dispatcher:refresh-stack
                             (mfa-tool.stack-store:selected-stack
                              store))))
 
 (defmethod mfa-tool.store:dispatch :after ((store stack-store)
                                            (action mfa-tool.aws-dispatcher:put-stack))
   (let* ((stack (mfa-tool.aws-dispatcher:stack action))
          (old-stack (find (daydreamer.aws-result:stack-name stack)
                           (available-stacks store)
                           :key 'daydreamer.aws-result:stack-name
                           :test 'equal))
          (new-stacks (substitute stack old-stack (available-stacks store))))
     (mfa-tool.store:dispatch store (mfa-tool.aws-dispatcher:select-stack stack))
     (mfa-tool.store:dispatch store (mfa-tool.aws-dispatcher:update-stacks new-stacks))))
 

 (defmethod mfa-tool.store:dispatch :after ((store stack-store)
                                            (action mfa-tool.aws-dispatcher:update-stacks))

   (when (not (selected-stack store))
     (alexandria:when-let ((stack (car (mfa-tool.aws-dispatcher:stacks action))))
       (mfa-tool.store:dispatch store (mfa-tool.aws-dispatcher:select-stack stack)))))
 
 (defmethod mfa-tool.store:execute ((store stack-store) (action (eql :refresh)))
   )

 
 (defmethod mfa-tool.store:execute ((store stack-store) (action mfa-tool.aws-dispatcher:update-stacks))
   (setf (available-stacks store) (sort (mfa-tool.aws-dispatcher:stacks action)
                                        'string-lessp
                                        :key 'daydreamer.aws-result:stack-name)))
 
 (defmethod mfa-tool.store:execute ((store stack-store) (action mfa-tool.aws-dispatcher:select-stack))
   (let ((stack (mfa-tool.aws-dispatcher:stack action)))
     (setf (selected-stack store) stack
 
           (parameters store) (mapcar 'parameter-columns (daydreamer.aws-result:parameters stack))
 
           (outputs store) (mapcar 'output-columns (daydreamer.aws-result:outputs stack)))))

 
 (defmethod mfa-tool.store:execute ((store stack-store) (action mfa-tool.aws-dispatcher:put-stack))
   )