(defsuite
  "page-helpers-extract-kwargs"
  (deftest
    "extracts keyword from define-special-form"
    (let
      ((result (extract-define-kwargs (quote (define-special-form "if" :category "Control" :arity 3)))))
      (assert-true (dict? result))
      (assert-equal "Control" (get result "category"))))
  (deftest
    "extracts multiple kwargs"
    (let
      ((result (extract-define-kwargs (quote (define-special-form "let" :category "Binding" :syntax "special")))))
      (assert-equal "Binding" (get result "category"))
      (assert-equal "special" (get result "syntax"))))
  (deftest
    "no kwargs returns empty dict"
    (let
      ((result (extract-define-kwargs (quote (define-special-form "begin")))))
      (assert-true (dict? result))
      (assert-equal 0 (len (keys result))))))

(defsuite
  "page-helpers-categorize"
  (deftest
    "groups define-special-form expressions"
    (let
      ((cats (categorize-special-forms (list (quote (define-special-form "if" :category "Control")) (quote (define-special-form "when" :category "Control")) (quote (define-special-form "let" :category "Binding"))))))
      (assert-true (dict? cats))
      (assert-true (has-key? cats "Control"))
      (assert-true (has-key? cats "Binding"))
      (assert-equal 2 (len (get cats "Control")))))
  (deftest
    "ignores non-special-form expressions"
    (let
      ((cats (categorize-special-forms (list (quote (define x 1)) (quote (define-special-form "if" :category "Control"))))))
      (assert-true (has-key? cats "Control"))
      (assert-equal 1 (len (get cats "Control")))))
  (deftest
    "empty input returns empty dict"
    (let
      ((cats (categorize-special-forms (list))))
      (assert-true (dict? cats))
      (assert-equal 0 (len (keys cats))))))

(defsuite
  "page-helpers-ref-items"
  (deftest
    "builds 2-field items with href"
    (let
      ((items (build-ref-items-with-href (list (list "alpha" "Description of alpha") (list "beta" "Description of beta")) "/ref" (list "alpha" "beta") 2)))
      (assert-equal 2 (len items))
      (let
        ((item (first items)))
        (assert-true (dict? item))
        (assert-true (has-key? item "href"))
        (assert-true (string-contains? (get item "href") "alpha")))))
  (deftest
    "builds 3-field items with href"
    (let
      ((items (build-ref-items-with-href (list (list "add" "(a b)" "Adds two numbers")) "/ref" (list "add") 3)))
      (assert-equal 1 (len items))
      (assert-true (has-key? (first items) "href"))))
  (deftest
    "empty input returns empty"
    (assert-equal
      (list)
      (build-ref-items-with-href (list) "/ref" (list) 2))))

(defsuite
  "page-helpers-component-source"
  (deftest
    "builds defcomp source string"
    (let
      ((src (build-component-source {:has-children false :body-sx "(div title)" :params (list "&key" "title") :type "component" :name "~my-card" :affinity nil})))
      (assert-true (string? src))
      (assert-true (string-contains? src "defcomp"))
      (assert-true (string-contains? src "~my-card"))))
  (deftest
    "builds defisland source string"
    (let
      ((src (build-component-source {:has-children false :body-sx "(span count)" :params (list "&key" "count") :type "island" :name "~counter" :affinity nil})))
      (assert-true (string-contains? src "defisland"))))
  (deftest
    "not-found returns comment"
    (let
      ((src (build-component-source {:has-children false :body-sx "" :params (list) :type "not-found" :name "~missing" :affinity nil})))
      (assert-true (string-contains? src "not found")))))

(defsuite
  "page-helpers-routing-analysis"
  (deftest
    "classifies pages with data as server"
    (let
      ((result (build-routing-analysis (list {:content-src "(div)" :data (quote (query "items")) :name "home"}))))
      (assert-true (dict? result))
      (assert-true (has-key? result "pages"))
      (let
        ((page (first (get result "pages"))))
        (assert-equal "server" (get page "mode")))))
  (deftest
    "classifies pages with content-src and no data as client"
    (let
      ((result (build-routing-analysis (list {:content-src "(div \"about\")" :name "about"}))))
      (let
        ((page (first (get result "pages"))))
        (assert-equal "client" (get page "mode")))))
  (deftest
    "classifies pages with empty content-src as server"
    (let
      ((result (build-routing-analysis (list {:content-src "" :name "empty"}))))
      (let
        ((page (first (get result "pages"))))
        (assert-equal "server" (get page "mode")))))
  (deftest
    "counts server and client"
    (let
      ((result (build-routing-analysis (list {:content-src "(div)" :data (quote (q)) :name "a"} {:content-src "(div)" :name "b"} {:content-src "(div)" :name "c"}))))
      (assert-equal 1 (get result "server-count"))
      (assert-equal 2 (get result "client-count"))))
  (deftest
    "empty pages"
    (let
      ((result (build-routing-analysis (list))))
      (assert-true (dict? result))
      (assert-equal 0 (len (get result "pages"))))))

(defsuite
  "page-helpers-bundle-analysis"
  (deftest
    "computes stats for pages"
    (let
      ((analysis (build-bundle-analysis (list {:needed-components (list "card" "btn") :name "home"}) {:btn {:io-refs (list "fetch") :is-pure false} :card {:io-refs (list) :is-pure true}} 10 5 7 3)))
      (assert-true (dict? analysis))
      (assert-true (has-key? analysis "total-components"))
      (assert-equal 10 (get analysis "total-components"))))
  (deftest
    "empty pages returns summary"
    (let
      ((analysis (build-bundle-analysis (list) {} 0 0 0 0)))
      (assert-true (dict? analysis)))))

(defsuite
  "page-helpers-category-map"
  (deftest
    "special-form-category-map is a dict"
    (assert-true (dict? special-form-category-map)))
  (deftest
    "maps known forms to categories"
    (assert-true (has-key? special-form-category-map "if"))
    (assert-true (has-key? special-form-category-map "let"))
    (assert-true (has-key? special-form-category-map "define"))))