com.biutthapa/vary {:mvn/version "0.0.1"}

[com.biutthapa/vary "0.0.1"]

(ns coffee-shop
  (:require [vary.core :refer [vary cases match]]))

;; Simple variant with keywords
(vary Color #{:red :blue :green})

;; Variant with associated values
(vary CoffeeSize
  {:small  {:label "Small"  :price 3.50 :volume 8}
   :medium {:label "Medium" :price 4.00 :volume 12}
   :large  {:label "Large"  :price 4.50 :volume 16}})

;; Variant with fields
(vary OrderStatus
  {:pending []
   :completed [:amount :double]
   :failed [:reason :string]})

(cases Color)
;; => {:red {}, :blue {}, :green {}}

(cases CoffeeSize)
;; => {:small {:label "Small" :price 3.50 :volume 8}, ...}

(doseq [[size props] (cases CoffeeSize)]
  (println (:label props) ": $" (format "%.2f" (:price props)) " for " (:volume props) " oz"))
;; => Small: $3.50 for 8 oz
;;    Medium: $4.00 for 12 oz
;;    Large: $4.50 for 16 oz

;; For simple cases
(defn color-name [color]
  (match color Color
    :red "Red"
    :blue "Blue"
    :green "Green"))

(println (color-name :blue)) ;; => "Blue"

;; For fields
(defn handle-order [order]
  (match order OrderStatus
    :pending "Order is pending"
    [:completed amount] (str "Completed with amount: " amount)
    [:failed reason] (str "Failed: " reason)))

(println (handle-order {:type :completed :amount 5.50})) ;; => "Completed with amount: 5.50"

(defn order-summary [order]
  (let [size (:size order)]
    (str "Order: " (:coffee-type order) " (" (CoffeeSize-label size)
         ", " (CoffeeSize-volume size) " oz) - $" (format "%.2f" (CoffeeSize-price size)))))

(println (order-summary {:coffee-type "Latte" :size :medium}))
;; => Order: Latte (Medium, 12 oz) - $4.00

{:lint-as {vary.core/vary clojure.core/def}
 :hooks
 {:analyze-call
  {vary.core/vary
   {:analyze
    (fn [{:keys [:node]}]
      (let [children (:children node)
            vary-name (when (>= (count children) 2) (nth children 1))
            case-map (when (>= (count children) 3) (nth children 2))
            is-symbol-node (fn [n] (and (map? n) (= :token (:tag n))))
            is-map-node (fn [n] (and (map? n) (= :map (:tag n))))
            is-keyword-node (fn [n] (and (map? n) (= :keyword (:tag n))))
            associated-values (when (and vary-name case-map
                                         (is-symbol-node vary-name)
                                         (is-map-node case-map))
                                (->> (:children case-map)
                                     (partition 2)
                                     (map second)
                                     (filter is-map-node)
                                     (mapcat :children)
                                     (partition 2)
                                     (map first)
                                     (filter is-keyword-node)
                                     (map :value)
                                     (map name)
                                     distinct))]
        {:defined-by :clj-kondo.hooks/defined
         :defined-fns (if (and vary-name associated-values (is-symbol-node vary-name))
                        (mapv (fn [field]
                                (symbol (str (name (:value vary-name)) "-" field)))
                              associated-values)
                        [])}))}}}}