(import test
        (chicken base)
        (chicken format)
        (chicken port)
        (chicken string)
        (chicken io)
        (srfi-34)	 ;;Exception Handling
        (srfi-35)	 ;;Exception Types
        (srfi-158)	 ;;Generators
)

(include-relative "../srfi-180.impl.scm")

(test-group "Whitespace predicate"
  (test "#\\space"
    #t (is-whitespace? #\space)))

(test-group "JSON Generator"
  (test "Basic test"
        '(array-start 1 2 3 "Hello" object-start "a" 1 object-end array-end)
        (with-input-from-string "[1, 2, 3, \"Hello\", {\"a\", 1}] true [5 4 3 2]"
          (lambda ()
            (let ((generator (json-generator)))
              (let loop ((accu '()))
                (let ((token (generator)))
                  (if (not (eof-object? token))
                      (loop (cons token accu))
                      (reverse accu)))))))))

(test-group "Array delimiter reading"
  (let-values (((generator-peek generator-pop)
                (make-peekable-generator
                 (list->generator
                  '(#\[ #\])))))
    (test "Start delimiter"
          '(array-start 1)
          (let-values (((val charcount nesting-delta)
                        (read-array-start 0 generator-peek generator-pop)))
            (list val charcount)))
    (test "End delimiter"
          '(array-end 9)
          (let-values (((val charcount nesting-delta)
                        (read-array-end 8 generator-peek generator-pop)))
            (list val charcount)))))

(test-group "Object delimiter reading"
  (let-values (((generator-peek generator-pop)
                (make-peekable-generator
                 (list->generator
                  '(#\{ #\})))))
    (test "Start delimiter"
          '(object-start 1)
          (let-values (((val charcount nesting-delta)
                        (read-object-start 0 generator-peek generator-pop)))
            (list val charcount)))
    (test "End delimiter"
          '(object-end 5)
          (let-values (((val charcount nesting-delta)
                        (read-object-end 4 generator-peek generator-pop)))
            (list val charcount)))))

(test-group "Null reading"
  (let-values (((generator-peek generator-pop)
                (make-peekable-generator
                 (list->generator
                  '(#\n #\u #\l #\l #\space)))))
    (test "Null reading"
          '(null 4)
          (let-values (((val charcount nesting-delta)
                        (read-null-sym 0 generator-peek generator-pop)))
            (list val charcount)))))

(test-group "Boolean reading"
  (let-values (((generator-peek generator-pop)
                (make-peekable-generator
                 (list->generator
                  '(#\t #\r #\u #\e #\space)))))
    (test "True values"
          '(#t 4)
          (let-values (((val charcount nesting-delta)
                        (read-boolean 0 generator-peek generator-pop)))
            (list val charcount)))))

(test-group "Number reading"
  (let-values (((generator-peek generator-pop)
                (make-peekable-generator
                 (list->generator
                  '(#\1 #\2 #\3 #\4 #\space)))))
    (test "Integer"
          '(1234 4)
          (let-values (((val charcount nesting-delta)
                        (read-number 0 generator-peek generator-pop)))
            (list val charcount)))))

(test-group "String reading"
  (let-values (((generator-peek generator-pop)
                (make-peekable-generator
                 (list->generator
                  '(#\" #\T #\e #\s #\t #\space #\T #\e #\s #\\ #\" #\t #\" #\space)))))
    (test "String"
          '("Test Tes\"t" 13)
          (let-values (((val charcount nesting-delta)
                        (read-string 0 generator-peek generator-pop)))
            (list val charcount)))))

(test-group "JSON folding"
  (test "Single value"
        42
        (with-input-from-string "42 25"
          (lambda ()
            (json-fold json-proc json-array-start json-array-end json-object-start json-object-end '()))))
  (test "Simple array"
        #(24 42 43)
        (with-input-from-string "[24 42 43]"
          (lambda ()
            (json-fold json-proc json-array-start json-array-end json-object-start json-object-end '()))))
  (test "Nested array"
        #(24 #(42 24) 42)
        (with-input-from-string "[24 [42 24] 42]"
          (lambda ()
            (json-fold json-proc json-array-start json-array-end json-object-start json-object-end '()))))
  (test "Nested object"
        '((a . 1) (b . 2) (c . ((d . 4))))
        (with-input-from-string "{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}"
          (lambda ()
            (json-fold json-proc json-array-start json-array-end json-object-start json-object-end '())))))

(test-group "JSON Accumulator"
    (test "Accumulate a number"
          "1234"
          (with-output-to-string
            (lambda ()
              ((json-accumulator) 1234))))
    (test "Accumulate a string"
          "\"Accumulator\""
          (with-output-to-string
            (lambda ()
              ((json-accumulator) "Accumulator"))))
    (test "Accumulate an empty string"
          "\"\""
          (with-output-to-string
            (lambda ()
              ((json-accumulator) ""))))
    (test "Accumulate a boolean"
          "true"
          (with-output-to-string
            (lambda ()
              ((json-accumulator) #t))))
    (test "Accumulate an array"
          "[1,2,3,true,null,\"Test\"]"
          (with-output-to-string
            (lambda ()
              ((json-accumulator)
               #(1 2 3 #t null "Test")))))
    (test "Accumulate an empty array"
          "[]"
          (with-output-to-string
            (lambda ()
              ((json-accumulator)
               #()))))
    (test "Accumulate an alist"
          "{\"a\":1,\"b\":2}"
          (with-output-to-string
            (lambda ()
              ((json-accumulator)
               '((a . 1) (b . 2))))))
    (test "Accumulate an empty alist"
          "{}"
          (with-output-to-string
            (lambda ()
              ((json-accumulator)
               '())))))

(test-exit)