(load "Test.carp")
(use Test)
(use StaticArray)

(deftest test

  (let [arr $[1 2 4]]
    (assert-equal test
                  $[2 4 8]
                  (do
                    (map! arr &(fn [val] (* @val 2)))
                    arr)
                  "map! works as expected"))

  (let [arr $[1 2 3]]
    (assert-equal test
                  $[3 2 1]
                  (do
                    (reverse! arr)
                    arr)
                  "reverse! works as expected"))

  (assert-true test
               (= $[1 2 3] $[1 2 3])
               "= works as expected I")

  (assert-false test
                (= $[1 2 3] $[1 2 3 4 5])
                "= works as expected II")

  (assert-false test
                (= $[1 1 1] $[0 0 0])
                "= works as expected III")

  (assert-equal test
                5
                (let [a $[0 1 2 3 4 5 6 7 8 9]]
                  @(unsafe-nth a 5))
                "unsafe-nth works as expected")

  (assert-equal test
                &[4 5 6]
                &(let [nested $[[1 2 3]
                                [4 5 6]
                                [7 8 9]]]
                   @(unsafe-nth nested 1))
                "unsafe-nth works as expected with heap allocated elements")

  (assert-equal test
                10
                (let [arr $[2 2 2 2]]
                  (reduce
                    &(fn [acc val] (+ acc @val))
                    2
                    arr))
                "reduce works as expected")

  (assert-equal test
                true
                (empty? (the (Ref (StaticArray Int)) $[]))
                "empty? works as expected I")

  (assert-equal test
                false
                (empty? $[1])
                "empty? works as expected II")

  (assert-equal test
                true
                (any? &(fn [x] (= 0 @x)) $[0 1 2 3])
                "any? works as expected I")

  (assert-equal test
                false
                (any? &(fn [x] (= 0 @x)) $[1 2 3 4])
                "any? works as expected II")

  (assert-equal test
                true
                (all? &(fn [x] (< 0 @x)) $[1 2 3])
                "all? works as expected I")

  (assert-equal test
                false
                (all? &(fn [x] (< 0 @x)) $[0 1 2])
                "all? works as expected II")

  (assert-equal test
                &(Maybe.Just 3)
                &(find &(fn [x] (= 3 @x)) $[0 1 2 3])
                "find works as expected I")

  (assert-nothing test
                  &(find &(fn [x] (= 4 @x)) $[0 1 2 3])
                  "find works as expected II")

  (assert-nothing test
                  &(find-index &(fn [i] (Int.even? @i)) $[1 3 5])
                  "find-index works I")

  (assert-equal test
                &(Maybe.Just 1)
                &(find-index &(fn [i] (Int.even? @i)) $[1 8 5])
                "find-index works II")

  (assert-equal test
                1
                (unsafe-first $[1 2 3])
                "unsafe-first works as expected")

  (assert-equal test
                &(Maybe.Just 1)
                &(first $[1 2 3])
                "first works as expected")

  (assert-nothing test
                  &(first (the (Ref (StaticArray Int)) $[]))
                  "first works as expected on empty array")

  (assert-equal test
                \c
                (unsafe-last $[\a \b \c])
                "unsafe-last works as expected")

  (assert-equal test
                &(Maybe.Just \c)
                &(last $[\a \b \c])
                "last works as expected")

  (assert-nothing test
                  &(last (the (Ref (StaticArray Char)) $[]))
                  "last works as expected on empty array")

  (assert-equal test
                &(Maybe.Just 10)
                &(maximum $[8 10 9])
                "maximum works as expected")

  (assert-equal test
                &(Maybe.Just (Pair.init 2 1))
                &(maximum $[(Pair.init 1 3) (Pair.init 2 1) (Pair.init 2 0)])
                "maximum works on pairs")

  (assert-equal test
                &(Maybe.Just 1)
                &(minimum $[3 1 2])
                "minimum works as expected")

  (assert-equal test
                &(Maybe.Just (Pair.init 1 3))
                &(minimum $[(Pair.init 1 3) (Pair.init 2 1) (Pair.init 2 0)])
                "minimum works on pairs")

  (assert-equal test
                55
                (sum $[1 2 3 4 5 6 7 8 9 10])
                "sum works as expected")

  (assert-equal test
                &(Maybe.Just 3)
                &(index-of $[1 2 3 4] &4)
                "index-of works as expected when element is in the array")

  (assert-nothing test
                  &(index-of $[1 2 3 4] &7)
                  "index-of works as expected when element is not in the array")

  (assert-equal test
                2
                (element-count $[1 4 3 4] &4)
                "element-count works as expected")

  (assert-equal test
                2
                (predicate-count $[1 8 5 10 3] &(fn [i] (Int.even? @i)))
                "predicate-count works")

  (let [arr $[1 2]]
    (assert-equal test
                  $[1 3]
                  (do
                    (aupdate! arr 1 &inc)
                    arr)
                  "aupdate! works as expected"))

  (let [arr $[1 2]]
    (assert-equal test
                  $[2 1]
                  (do
                    (StaticArray.swap! arr 0 1)
                    arr)
                  "swap! works as expected"))

  (assert-nothing test
                  &(nth $[0 1 2] 3)
                  "nth works as expected I")

  (assert-equal test
                &(Maybe.Just 0)
                &(nth $[0 1 2] 0)
                "nth works as expected II")

  (assert-true test
                (contains? $[0 1 2] &1)
                "contains? works as expected I")

  (assert-false test
                (contains? $[0 1 2] &100)
                "contains? works as expected II")

  (assert-equal test
                &1
                (Pointer.to-ref (unsafe-raw $[1 2 3]))
                "unsafe-raw works as expected")

  (assert-equal test
                &2
                (Pointer.to-ref (Pointer.inc (unsafe-raw $[1 2 3])))
                "unsafe-raw works as expected II")

  (let [arr $[1 1 1 1 1]]
    (assert-equal test
                  $[1 2 3 4 5]
                  (do
                    (StaticArray.scan! &Int.+ arr)
                    arr)
                  "scan! works"))

  )