#lang racket/base

(require "../main.rkt")

(provide usecase-random-number
         usecase-unique-values
         usecase-array-at
         usecase-sum-to
         usecase-make-adder
         usecase-set-html
         all-js-usecases
         show-js-usecases
         write-js-usecases-file)

;; Use case 01: generate a random integer between 1 and 5.
(define usecase-random-number
  (js
   (define (randomBetween1And5)
     (return (+ (send Math floor (* (send Math random) 5)) 1)))))

;; Use case 02: get unique values from an array with duplicates using Set.
(define usecase-unique-values
  (js
   (define (uniqueValues xs)
     (return (send Array from (new Set xs))))))

;; Use case 03: indexed array access with js-ref.
(define usecase-array-at
  (js
   (define (arrayAt xs i)
     (return (js-ref xs i)))))

;; Use case 04: named let as a loop.  The branch that leaves the loop uses an
;; explicit return, because js-maker 3 is statement-oriented.
(define usecase-sum-to
  (js
   (define (sumTo n)
     (let loop ([i 0] [acc 0])
       (if (> i n)
           (return acc)
           (loop (+ i 1) (+ acc i)))))))

;; Use case 05: return a JavaScript function value.
(define usecase-make-adder
  (js
   (define (makeAdder x)
     (return (lambda (y)
               (return (+ x y)))))))

;; Use case 06: small DOM setter.  It uses send, js-dot and set!.
(define usecase-set-html
  (js
   (define (setHtml id html)
     (let ([el (send document getElementById id)])
       (set! (js-dot el innerHTML) html)
       (return (js-dot el innerHTML))))))

(define all-js-usecases
  `((random-number . ,usecase-random-number)
    (unique-values . ,usecase-unique-values)
    (array-at . ,usecase-array-at)
    (sum-to . ,usecase-sum-to)
    (make-adder . ,usecase-make-adder)
    (set-html . ,usecase-set-html)))

(define (show-js-usecases)
  (for ([entry (in-list all-js-usecases)])
    (displayln (format "// ~a" (car entry)))
    (displayln (cdr entry))
    (newline)))

(define (write-js-usecases-file [path "demo/js-usecases.generated.js"])
  (call-with-output-file path #:exists 'replace
    (lambda (out)
      (for ([entry (in-list all-js-usecases)])
        (displayln (format "// ~a" (car entry)) out)
        (displayln (cdr entry) out)
        (newline out)))))

(module+ main
  (show-js-usecases))