(define
  test-set-attr-sep
  (fn (el name val) (effect (fn () (dom-set-attr el name val)))))

(define
  test-set-attr-mod
  (fn (el name val) (effect (fn () (dom-set-attr el name val)))))

(define test-reactive-sig (signal "before"))

(defsuite
  "wasm-basic"
  (deftest "arithmetic" (assert-equal 3 (+ 1 2)))
  (deftest
    "div preserves keywords"
    (assert-equal
      "(div :class \"test\" \"hello\")"
      (inspect (div :class "test" "hello"))))
  (deftest
    "render div+class"
    (assert-equal
      "<div class=\"card\">content</div>"
      (render-to-html (div :class "card" "content")))))

(defsuite
  "wasm-dom-rendering"
  (deftest
    "dom class attr"
    (assert-equal
      "test"
      (dom-get-attr
        (render-to-dom (div :class "test" "hello") (global-env) nil)
        "class"))))

(defsuite
  "wasm-scoped"
  (deftest
    "static class in island scope"
    (assert-equal
      "scoped"
      (dom-get-attr
        (let
          ((d (list)))
          (with-island-scope
            (fn (x) (append! d x))
            (fn
              ()
              (render-to-dom (div :class "scoped" "text") (global-env) nil))))
        "class")))
  (deftest
    "signal attr initial value"
    (assert-equal
      "active"
      (dom-get-attr
        (let
          ((s (signal "active")) (d (list)))
          (with-island-scope
            (fn (x) (append! d x))
            (fn
              ()
              (render-to-dom
                (div :class (deref s) "content")
                (global-env)
                nil))))
        "class")))
  (deftest
    "signal text in scope"
    (assert-true
      (contains?
        (host-get
          (let
            ((s (signal 42)) (d (list)))
            (with-island-scope
              (fn (x) (append! d x))
              (fn () (render-to-dom (div (deref s)) (global-env) nil))))
          "outerHTML")
        "42"))))

(defsuite
  "wasm-define-effect"
  (deftest
    "define+effect+host-obj (same eval)"
    (assert-equal
      "from-define"
      (do
        (define
          test-set-attr-inline
          (fn (el name val) (effect (fn () (dom-set-attr el name val)))))
        (let
          ((el (dom-create-element "div" nil)))
          (test-set-attr-inline el "class" "from-define")
          (dom-get-attr el "class")))))
  (deftest
    "define+effect body executes"
    (assert-equal
      "1:ran"
      (do
        (define
          test-fx-log-inline
          (fn
            (el log)
            (effect
              (fn () (append! log "ran") (dom-set-attr el "class" "fx")))))
        (let
          ((el (dom-create-element "div" nil)) (log (list)))
          (test-fx-log-inline el log)
          (str (len log) ":" (first log))))))
  (deftest
    "let+effect+host-obj"
    (assert-equal
      "from-let"
      (let
        ((test-set-attr-let (fn (el name val) (effect (fn () (dom-set-attr el name val))))))
        (let
          ((el (dom-create-element "div" nil)))
          (test-set-attr-let el "class" "from-let")
          (dom-get-attr el "class"))))))

(defsuite
  "wasm-module-loaded"
  (deftest
    "define+effect+host-obj (separate eval)"
    (assert-equal
      "from-sep-define"
      (let
        ((el (dom-create-element "div" nil)))
        (test-set-attr-sep el "class" "from-sep-define")
        (dom-get-attr el "class"))))
  (deftest
    "define+effect+host-obj (module-loaded)"
    (assert-equal
      "from-mod"
      (let
        ((el (dom-create-element "div" nil)))
        (test-set-attr-mod el "class" "from-mod")
        (dom-get-attr el "class")))))

(defsuite
  "wasm-reactive"
  (deftest
    "reactive-spread from module"
    (assert-equal
      "sx-text-center"
      (let
        ((el (dom-create-element "div" nil)) (d (list)))
        (with-island-scope
          (fn (x) (append! d x))
          (fn
            ()
            (reactive-spread el (fn () (~cssx/tw :tokens "text-center")))))
        (dom-get-attr el "class"))))
  (deftest
    "render-to-dom CSSX in island scope"
    (assert-true
      (contains?
        (host-get
          (let
            ((d (list)))
            (with-island-scope
              (fn (x) (append! d x))
              (fn
                ()
                (render-to-dom
                  (quote
                    (div (~cssx/tw :tokens "text-center font-bold") "hello"))
                  (global-env)
                  nil))))
          "outerHTML")
        "sx-text-center"))))

(defsuite
  "wasm-signal-propagation"
  (deftest
    "reactive attr update"
    (do
      (set! test-reactive-sig (signal "before"))
      (assert-equal
        "after"
        (let
          ((d (list)))
          (let
            ((el (with-island-scope (fn (x) (append! d x)) (fn () (render-to-dom (quote (div :class (deref test-reactive-sig) "content")) (global-env) nil)))))
            (reset! test-reactive-sig "after")
            (dom-get-attr el "class")))))))