(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"]))))

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

(deftest empty-list-items-test
  (testing "map over empty vector should not produce LazySeq string"
    (is (= "<ul></ul>"
           (empty-list-items []))))
  (testing "map over non-empty vector should work"
    (is (= "<ul><li>one</li><li>two</li></ul>"
           (empty-list-items ["one" "two"])))))

(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"))))))

  (testing "a nil node"
    (is (= nil
           ($ nil))))

  (testing "a string node"
    (is (= {:node/name :dompa/text
            :node/value "hello world"}
           ($ "hello world"))))

  (testing "a node of multiple sub-nodes"
    (is (= {:node/name :<>
            :node/children [{:node/name :dompa/text
                             :node/value "hello"}
                            {:node/name :dompa/text
                             :node/value "12345"}
                            {:node/name :dompa/text
                             :node/value "123.3"}
                            {:node/name :dompa/text
                             :node/value "world"}]}
           ($ "hello" 12345 nil 123.3 "world")))

    (is (= {:node/name :<>
            :node/children [{:node/name :dompa/text
                             :node/value "hello"}
                            {:node/name :dompa/text
                             :node/value "12345"}
                            {:node/name :<>
                             :node/children [{:node/name :dompa/text
                                              :node/value "w"}
                                             {:node/name :dompa/text
                                              :node/value "o"}
                                             {:node/name :dompa/text
                                              :node/value "r"}
                                             {:node/name :dompa/text
                                              :node/value "l"}
                                             {:node/name :dompa/text
                                              :node/value "d"}]}]}
           ($ "hello" 12345 (map #($ %) ["w" "o" "r" "l" "d"]))))

    (is (= {:node/name :<>
            :node/children [{:node/name :dompa/text
                             :node/value "hello"}
                            {:node/name :<>
                             :node/children [{:node/name :dompa/text
                                              :node/value "w"}
                                             {:node/name :<>
                                              :node/children [{:node/name :dompa/text
                                                               :node/value "o"}
                                                              {:node/name :dompa/text
                                                               :node/value "r"}
                                                              {:node/name :<>
                                                               :node/children [{:node/name :dompa/text
                                                                                :node/value "l"}
                                                                               {:node/name :dompa/text
                                                                                :node/value "d"}]}]}]}]}
           ($ "hello"
              (map (fn [x]
                     ($ x))
                   ["w" (map (fn [x]
                               ($ x))
                             ["o" "r" (map (fn [x]
                                             ($ x))
                                           ["l" "d"])])]))))))

(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)))))