(ns forms.dataflow
  (:require [com.stuartsierra.dependency :as dep]
            [medley.core :as med]
            [rum.core :as rum]))

(def base (atom 0))

(def reactive-spec
  {:base   [[] base]
   :inc    [[:base] (fn [base] (inc base))]
   :as-map [[:base :inc] (fn [base inc] {:base base :after-inc inc})]
   :sum    [[:as-map] (fn [as-map] (+ (:base as-map) (:after-inc as-map)))]})

(defn depend'
  [graph node deps]
  (reduce (fn [graph dep]
            (dep/depend graph node dep))
          graph
          deps))

(defn spec->graph [spec]
  (reduce-kv (fn [graph id [dependencies]]
               (depend' graph id dependencies))
             (dep/graph)
             spec))

(defn build
  [spec]
  (let [graph (spec->graph spec)]
    (reduce (fn [m k]
              (let [[direct-deps derive] (-> spec k)]
                (prn direct-deps)
                (if (fn? derive)
                  (assoc m k (rum/derived-atom (map m direct-deps) k derive))
                  (assoc m k derive))))
            {}
            (dep/topo-sort graph))))

(comment

  (build x)

  (def reactions
    (build x))

  (swap! base inc)

  (med/map-vals deref reactions)



  )