(ns dompa.nodes-test
  #?(:clj (:require
           [clojure.test :refer [deftest is testing]]
           [clojure.zip :as zip]
           [dompa.html :as html]
           [dompa.nodes :as nodes :refer [$ defhtml]]))
  #?(:cljs (:require [cljs.test :refer-macros [deftest testing is]]
                     [clojure.zip :as zip]
                     [dompa.nodes :as nodes :refer [$] :refer-macros [defhtml]]
                     [dompa.html :as html])))

(defhtml hello [who]
  ($ :div
     ($ "hello " who)))

(deftest defhtml-test
  (is (= "<div>hello world</div>"
         (hello "world"))))

(defhtml list-items [items]
  ($ :ul
     (->> items
          (map (fn [item]
                 ($ :li ($ item))))
          (into []))))

(deftest list-items-test
  (is (= "<ul><li>one</li><li>two</li><li>three</li></ul>"
         (list-items ["one" "two" "three"]))))

(deftest $-test
  (testing "a simple node"
    (is (= {:node/name     :div
            :node/children [{:node/name  :dompa/text
                             :node/value "hello world"}]}
           ($ :div ($ "hello world")))))

  (testing "a fragment node"
    (is (= {:node/name     :<>
            :node/children [{:node/name     :span
                             :node/children [{:node/name  :dompa/text
                                              :node/value "hello"}]}
                            {:node/name     :span
                             :node/children [{:node/name  :dompa/text
                                              :node/value "world"}]}]}
           ($ :<>
              ($ :span
                 ($ "hello"))
              ($ :span
                 ($ "world")))))))

(deftest traverse-test
  (let [traverser-fn (fn [node]
                       (if (= :dompa/text (:node/name node))
                         (assoc node :node/value "world hello")
                         node))]
    (is (= "<div>world hello</div>"
           (-> (html/->nodes "<div>hello world</div>")
               (nodes/traverse traverser-fn)
               nodes/->html)))))

(deftest zip-test
  (let [nodes (html/->nodes "<div><p>hello</p><p>world</p></div>")
        zipper (nodes/zip (first nodes))]
    (is (= :div
           (:node/name (zip/node zipper))))
    (is (= "hello"
           (-> zipper
               zip/down
               zip/down
               zip/node
               :node/value)))))