#lang racket/base

(require json
         "../main.rkt"
         "jsmaker-test-framework.rkt"
         "jsmaker-executors.rkt"
         "../demo/js-usecases.rkt")

(define timer-preamble
  #<<JS
const intervals = {};
let nextIntervalId = 1;
function setInterval(cb, ms) {
  const id = nextIntervalId++;
  intervals[id] = { cb, ms, active: true };
  return id;
}
function clearInterval(id) {
  if (intervals[id]) intervals[id].active = false;
}
function runInterval(id, times) {
  for (let i = 0; i < times; i++) {
    if (!intervals[id] || !intervals[id].active) break;
    intervals[id].cb();
  }
}
JS
  )

(define dom-preamble
  #<<JS
const body = { innerHTML: "<p>A</p>" };
const root = { innerHTML: "<p>A</p>" };
const document = {
  body,
  querySelector: (selector) => selector === "body" ? body : false,
  getElementById: (id) => id === "root" ? root : false
};
JS
  )

(define fetch-preamble
  #<<JS
function fetch(url) {
  if (url === "/ok") {
    return Promise.resolve({
      json: () => Promise.resolve({ title: "Done" })
    });
  }
  return Promise.reject(new Error("network"));
}
JS
  )

(define tests
  (list
   (js-program-test
    'use-random-number-1-to-5
    usecase-random-number
    (js/expression (randomBetween1And5))
    (jsexpr->string 5)
    #:preamble "Math.random = () => 0.80;")

   (js-program-test
    'use-unique-values-set
    usecase-unique-values
    (js/expression (uniqueValues (array 1 2 2 3 1)))
    (jsexpr->string '(1 2 3)))

   (js-program-test
    'use-six-falsey-values
    usecase-falsey-values
    (js/expression (send (falseyValues) map (lambda (x) (return (Boolean x)))))
    (jsexpr->string '(#f #f #f #f #f #f)))

   (js-program-test
    'use-currying-simple
    usecase-currying
    (js/expression ((add 2) 3))
    (jsexpr->string 5))

   (js-program-test
    'use-object-destructuring
    usecase-object-destructuring
    (js/expression (describePerson (object 'name "Ada" 'age 37)))
    (jsexpr->string "Ada:37"))

   (js-program-test
    'use-timer-clear-interval
    usecase-timer-interval
    (js/expression
     (let* ([t (startTimer)])
       (runInterval t.id 5)
       (array t.id (send t getTicks) (js-dot (js-ref intervals t.id) active))))
    (jsexpr->string '(1 3 #f))
    #:preamble timer-preamble)

   (js-program-test
    'use-object-get-set-delete-prop
    usecase-object-props
    (js/expression (objectProps))
    (jsexpr->string '(1 1 1 2 3 #f)))

   (js-program-test
    'use-string-concat-order
    usecase-string-concat-order
    (js/expression (concatOrder))
    (jsexpr->string '("33" "123")))

   (js-program-test
    'use-freeze-vs-seal
    usecase-freeze-vs-seal
    (js/expression (freezeVsSeal))
    (jsexpr->string '(1 9 #t #t #t)))

   (js-program-test
    'use-switch-example
    usecase-switch
    (js/expression (array (switchExample 1) (switchExample 2) (switchExample 9)))
    (jsexpr->string '("one" "two-or-three" "other")))

   (js-program-test
    'use-class-constructor-default
    usecase-class-constructor
    (js/expression (classExample))
    (jsexpr->string '("Hello world" "Hello Ada")))

   (js-program-test
    'use-sort-objects-by-property
    usecase-sort-objects-by-property
    (js/expression
     (send (sortByProperty (array (object 'age 30) (object 'age 20) (object 'age 25)) "age")
           map
           (lambda (x) (return x.age))))
    (jsexpr->string '(20 25 30)))

   (js-program-test
    'use-delete-array-elements-four-ways
    usecase-delete-array-elements
    (js/expression (deleteArrayWays (array "a" "b" "c")))
    (jsexpr->string '(("a" "c") ("a" "c") ("a" "c") (#f 3))))

   (js-program-test
    'use-bubble-sort
    usecase-bubble-sort
    (js/expression (bubbleSort (array 5 1 4 2 8)))
    (jsexpr->string '(1 2 4 5 8)))

   (js-program-test
    'use-binary-search-recursive
    usecase-binary-search
    (js/expression
     (array (binarySearch (array 1 3 5 7 9) 7 0 4)
            (binarySearch (array 1 3 5 7 9) 4 0 4)))
    (jsexpr->string '(3 -1)))

   (js-program-test
    'use-map-count-occurrences
    usecase-map-count-occurrences
    (js/expression (countOccurrences (array "a" "b" "a" "c" "b" "a")))
    (jsexpr->string '(("a" 3) ("b" 2) ("c" 1))))

   (js-program-test
    'use-get-html-three-ways
    usecase-get-html-three-ways
    (js/expression (getHtmlThreeWays))
    (jsexpr->string '("<p>A</p>" "<p>A</p>" "<p>A</p>"))
    #:preamble dom-preamble)

   (js-program-test
    'use-anagram
    usecase-anagram
    (js/expression (array (canArrange "listen" "silent")
                          (canArrange "abc" "abd")))
    (jsexpr->string '(#t #f)))

   (js-program-test
    'use-pairs-equal-target
    usecase-pairs-equal-target
    (js/expression (pairsEqualTarget (array 1 2 3 4 3 5) 6))
    (jsexpr->string '((2 4) (3 3) (1 5))))

   (js-program-test
    'use-fetch-api-results-errors
    usecase-fetch-api
    (js/expression (send Promise all (array (loadTitle "/ok") (loadTitle "/fail"))))
    "[{\"ok\":true,\"title\":\"Done\"},{\"ok\":false,\"message\":\"network\"}]"
    #:preamble fetch-preamble)))

(define engine (find-js-engine))
(run-jsmaker-regression 'jsmaker-usecases tests "/tmp/jsmaker-usecases.js" #:engine engine)