(ns auto-ap.status
  (:require [re-frame.core :as re-frame]))

;; (re-frame/reg-sub
;;  ::status
;;  (fn [db [_ which]]
;;    (get-in db [::status which])))
;; 
;; 
;; (defn loading [db which]
;;   (-> db 
;;       (assoc-in [::status which :state] :loading)
;;       (assoc-in [::status which :error] nil)))
;; 
;; (defn completion [db which]
;;   (-> db 
;;       (assoc-in [::status which :state] :loading)
;;       (assoc-in [::status which :error] nil)))
;; 
;; (defn triggers-loading [which]
;;   (re-frame/enrich
;;    (fn [db event]
;;      (loading db which))))
;; 
;; (defn triggers-completion [which]
;;   (re-frame/enrich
;;    (fn [db event]
;;      (completion db which))))
;; 
(defn class-for [which]
  (cond (= :loading (:state which))
    ["is-loading"]

    (= :error (:state which))
    ["animated" "shake"]

    :else
    []))


(re-frame/reg-sub
 ::multi
 (fn [db [_ multi]]
   (get-in db [::status multi])))

(re-frame/reg-sub
 ::single
 (fn [db [_ single]]
   (get-in db [::status single])))

(re-frame/reg-event-db
 ::loading-multi
 [(re-frame/path [::status]) ]
 (fn [db [_ multi which]]
   (assoc-in db [multi which] {:state :loading
                               :error nil})))

(re-frame/reg-event-db
 ::completed-multi
 [(re-frame/path [::status]) ]
 (fn [db [_ multi which]]
   (assoc-in db [multi which] {:state nil
                               :error nil})))

(re-frame/reg-event-db
 ::error-multi
 [(re-frame/path [::status]) ]
 (fn [db [_ multi which error]]
   (assoc-in db [multi which] {:state :error
                               :error error})))

(defn reset-multi [db multi]
  (assoc-in db [::status multi] {}))

(re-frame/reg-event-db
 ::loading
 [(re-frame/path [::status]) ]
 (fn [db [_ single]]
   (assoc db single {:state :loading
                     :error nil})))

(re-frame/reg-event-db
 ::completed
 [(re-frame/path [::status]) ]
 (fn [db [_ single which]]
   (assoc db single {:state nil
                     :error nil})))

(re-frame/reg-event-db
 ::error
 [(re-frame/path [::status]) ]
 (fn [db [_ single error]]
   (assoc db single {:state :error
                     :error error})))