#lang racket

;;; Tests for dds/utils.

(require rackunit graph "utils.rkt")

(test-case "HashTable Injection"
  (test-case "auto-hash-ref/explicit"
    (let ([mytable #hash((a . 3) (b . 4))])
      (check-equal? (auto-hash-ref/explicit (mytable b a)
                                            (* a b))
                    12))
    (let ([ht #hash((a . #t) (b . #f))])
      (check-equal? (auto-hash-ref/explicit (ht a b)
                                            (and (not a) b))
                    #f)))

  (test-case "auto-hash-ref/:"
    (let ([ht #hash((x . #t) (y . #t) (t . #f))]
          [z #t])
      (check-equal? (auto-hash-ref/: ht
                                     (and :x (not :y) z (or (and :t) :x)))
                    #f))
    (let ([ht #hash((a . 1) (b . 2))])
      (check-equal? (auto-hash-ref/: ht (+ :a (* 2 :b)))
                    5)))

  (test-case "eval-with"
    (check-equal? (let ([ht #hash((a . 1) (b . 1))])
                    (eval-with ht '(+ b a 1)))
                  3)))

(test-case "Analysis of quoted expressions"
  (check-equal? (extract-symbols '(1 (2 3) x (y z 3)))
                '(x y z)))

(test-case "Variable mapping and Org-mode"
  (check-equal? (any->string 'a) "a")
  (check-equal? (any->string '(a 1 (x y))) "(a 1 (x y))")
  (check-equal? (any->string "hello") "hello")
  (let ([mp (stringify-variable-mapping #hash((a . (and a b)) (b . (not b))))])
    (check-equal? (hash-ref mp 'a) "(and a b)")
    (check-equal? (hash-ref mp 'b) "(not b)"))
  (check-equal? (string->any "(or b (not a))") '(or b (not a)))
  (check-equal? (string->any "14") 14)
  (check-equal? (map-sexp add1 '(1 2 (4 10) 3)) '(2 3 (5 11) 4))
  (check-equal? (read-org-sexp "((\"a\" \"(and a b)\") (\"b\" \"(or b (not a))\"))")
                '((a (and a b)) (b (or b (not a)))))
  (check-equal? (read-org-sexp "(#t \"#t\" \"#t \" '(1 2 \"#f\"))")
                '(#t #t #t '(1 2 #f)))
  (check-equal? (unstringify-pairs '(("a" . "1") ("b" . "(and a (not b))")))
                '((a . 1) (b . (and a (not b)))))
  (check-equal? (unstringify-pairs '(("a" . 1) ("b" . "(and a (not b))")))
                '((a . 1) (b . (and a (not b)))))
  (let ([m1 (read-org-variable-mapping "((\"a\" \"(and a b)\") (\"b\" \"(or b (not a))\"))")]
        [m2 (read-org-variable-mapping "((\"a\" . \"(and a b)\") (\"b\" . \"(or b (not a))\"))")]
        [m3 (unorgv "((\"a\" . \"(and a b)\") (\"b\" . \"(or b (not a))\"))")])
    (check-equal? (hash-ref m1 'a) '(and a b))
    (check-equal? (hash-ref m2 'a) '(and a b))
    (check-equal? (hash-ref m3 'a) '(and a b))
    (check-equal? (hash-ref m1 'b) '(or b (not a)))
    (check-equal? (hash-ref m2 'b) '(or b (not a)))
    (check-equal? (hash-ref m3 'b) '(or b (not a))))
  (check-equal? (read-symbol-list "a b c") '(a b c))
  (check-equal? (drop-first-last "(a b)") "a b")
  (check-equal? (list-sets->list-strings (list (set 'x 'y) (set 'z) (set) (set 't)))
                '("y x" "z" "" "t"))
  (check-equal? (pretty-print-set-sets (set (set 'a 'b) (set 'c))) "{a b}{c}"))

(test-case "Additional graph utilities"
  (let* ([gr1 (directed-graph '((a b) (b c)))]
         [gr2 (undirected-graph '((a b) (b c)))]
         [dbl (λ (x) (let ([x-str (symbol->string x)])
                       (string->symbol (string-append x-str x-str))))]
         [new-gr1 (update-vertices/unweighted gr1 dbl)]
         [new-gr2 (update-vertices/unweighted gr2 dbl)]
         [new-gr1-ug (update-graph gr1 #:v-func dbl)]
         [new-gr2-ug (update-graph gr2 #:v-func dbl)]
         [gr3 (weighted-graph/directed '((10 a b) (11 b c)))]
         [new-gr3 (update-graph gr3 #:v-func dbl #:e-func (λ (x) (* 2 x)))])
    (check-false (has-vertex? new-gr1 'a))
    (check-true (has-vertex? new-gr1 'aa))
    (check-false (has-vertex? new-gr1 'b))
    (check-true (has-vertex? new-gr1 'bb))
    (check-false (has-vertex? new-gr1 'c))
    (check-true (has-vertex? new-gr1 'cc))
    (check-true (has-edge? new-gr1 'aa 'bb))
    (check-true (has-edge? new-gr1 'bb 'cc))

    (check-true (has-edge? new-gr2 'aa 'bb))
    (check-true (has-edge? new-gr2 'bb 'aa))
    (check-true (has-edge? new-gr2 'bb 'cc))
    (check-true (has-edge? new-gr2 'cc 'bb))

    (check-false (has-vertex? new-gr1-ug 'a))
    (check-true (has-vertex? new-gr1-ug 'aa))
    (check-false (has-vertex? new-gr1-ug 'b))
    (check-true (has-vertex? new-gr1-ug 'bb))
    (check-false (has-vertex? new-gr1-ug 'c))
    (check-true (has-vertex? new-gr1-ug 'cc))
    (check-true (has-edge? new-gr1-ug 'aa 'bb))
    (check-true (has-edge? new-gr1-ug 'bb 'cc))

    (check-true (has-edge? new-gr2-ug 'aa 'bb))
    (check-true (has-edge? new-gr2-ug 'bb 'aa))
    (check-true (has-edge? new-gr2-ug 'bb 'cc))
    (check-true (has-edge? new-gr2-ug 'cc 'bb))

    (check-true (has-edge? new-gr3 'aa 'bb))
    (check-false (has-edge? new-gr3 'bb 'aa))
    (check-true (has-edge? new-gr3 'bb 'cc))
    (check-false (has-edge? new-gr3 'cc 'bb))
    (check-equal? (edge-weight new-gr3 'aa 'bb) 20)
    (check-equal? (edge-weight new-gr3 'bb 'cc) 22)))

(test-case "Pretty printing"
  (check-equal? (pretty-print-set (set 'a 'b 1)) "1 a b"))

(test-case "Additional list utilties"
  (let-values ([(e1 l1) (collect-by-key '((1 2) (1 3)) '(a b))]
               [(e2 l2) (collect-by-key '((1 2) (1 2)) '(a b))]
               [(e3 l3) (collect-by-key/sets '(a b a) '(1 2 1))])
    (check-equal? e1 '((1 2) (1 3))) (check-equal? l1 '((a) (b)))
    (check-equal? e2 '((1 2))) (check-equal? l2 '((b a)))
    (check-equal? e3 '(a b)) (check-equal? l3 (list (set 1) (set 2))))
  (check-equal? (ht-values/list->set #hash((a . (1 1))))
                (hash 'a (set 1)))
  (check-equal? (hash->list/ordered #hash((b . 1) (a . 1)))
                '((a . 1) (b . 1)))
  (let-values ([(l1 l2) (multi-split-at '((1 2 3) (a b c)) 2)])
    (check-equal? l1 '((1 2) (a b))) (check-equal? l2 '((3) (c))))
  (check-equal? (lists-transpose '((1 2) (a b))) '((1 a) (2 b))))

(test-case "Functions"
  (check-true (procedure-fixed-arity? not))
  (check-false (procedure-fixed-arity? +)))

(test-case "Randomness"
  (begin
    (random-seed 0)
    (check-equal? (stream->list (stream-take (in-random 100) 10))
                  '(85 65 20 40 89 45 54 38 26 62))
    (check-equal? (stream->list (stream-take (in-random 50 100) 10))
                  '(75 59 82 85 61 85 59 64 75 53))
    (check-equal? (stream->list (stream-take (in-random) 10))
                  '(0.1656109603231493
                    0.9680391127132195
                    0.051518813640790355
                    0.755901955353936
                    0.5923534604277275
                    0.5513340634474264
                    0.7022057040731392
                    0.48375400938578744
                    0.7538961707172924
                    0.01828428516237329))))

(test-case "Additional stream utilities"
  (check-equal? (stream->list (cartesian-product/stream (in-range 3) (in-range 4 6) '(a b)))
                '((0 4 a)
                  (0 4 b)
                  (0 5 a)
                  (0 5 b)
                  (1 4 a)
                  (1 4 b)
                  (1 5 a)
                  (1 5 b)
                  (2 4 a)
                  (2 4 b)
                  (2 5 a)
                  (2 5 b))))