(.module:
  lux
  (lux (control [monad #+ do]
                pipe)
       (data ["e" error]
             [text])
       (lang ["//." synthesis])
       ["r" math/random]
       test)
  (luxc (lang (translation (jvm [".T_jvm" statement])
                           ## (js [".T_js" statement])
                           ## (lua [".T_lua" statement])
                           ## (ruby [".T_ruby" statement])
                           ## (python [".T_python" statement])
                           ## (r [".T_r" statement])
                           ## (scheme [".T_scheme" statement])
                           ## (common-lisp [".T_common-lisp" statement])
                           ## (php [".T_php" statement])
                           )))
  (test/luxc common))

(def: name-part
  (r.Random Text)
  (|> (r.ascii +5)
      (r.filter (function (_ sample)
                  (not (or (text.contains? "/" sample)
                           (text.contains? "[" sample)
                           (text.contains? "]" sample)))))))

(def: (definitions-spec define)
  (-> Definer Test)
  (do r.Monad<Random>
    [def-name (r.seq name-part name-part)
     def-value r.int]
    (test "Can refer to definitions."
          (|> (define def-name (//synthesis.i64 def-value))
              (case> (#e.Success valueT)
                     (i/= def-value (:coerce Int valueT))

                     (#e.Error error)
                     (exec (log! error)
                       #0))))))

(def: (variables-spec run)
  (-> Runner Test)
  (do r.Monad<Random>
    [register (|> r.nat (:: @ map (n/% +100)))
     value r.int]
    (test "Can refer to local variables/registers."
          (|> (run (//synthesis.branch/let [(//synthesis.i64 value)
                                            register
                                            (//synthesis.variable/local register)]))
              (case> (#e.Success outputT)
                     (i/= value (:coerce Int outputT))

                     (#e.Error error)
                     (exec (log! error)
                       #0))))))

(def: (references-spec run define)
  (-> Runner Definer Test)
  (seq (definitions-spec define)
       (variables-spec run)))

(context: "[JVM] References."
  (<| (times +100)
      (references-spec run-jvm def-jvm)))

## (context: "[JS] References."
##   (<| (times +100)
##       (references-spec run-js def-js)))

## (context: "[Lua] References."
##   (<| (times +100)
##       (references-spec run-lua def-lua)))

## (context: "[Ruby] References."
##   (<| (times +100)
##       (references-spec run-ruby def-ruby)))

## (context: "[Python] References."
##   (<| (times +100)
##       (references-spec run-python def-python)))

## (context: "[R] References."
##   (<| (times +100)
##       (references-spec run-r def-r)))

## (context: "[Scheme] References."
##   (<| (times +100)
##       (references-spec run-scheme def-scheme)))

## (context: "[Common Lisp] References."
##   (<| (times +100)
##       (references-spec run-common-lisp def-common-lisp)))

## (context: "[PHP] References."
##   (<| (times +100)
##       (references-spec run-php def-php)))