(;module:
  lux
  (lux [io]
       (control [monad #+ do]
                pipe)
       (data ["e" error]
             [maybe]
             [bool "bool/" Eq<Bool>]
             [text "text/" Eq<Text>]
             text/format
             (coll [array]
                   [list]))
       ["r" math/random "r/" Monad<Random>]
       [meta]
       (meta [code])
       [host]
       test)
  (luxc [";L" host]
        (lang ["ls" synthesis])
        [analyser]
        [synthesizer]
        (generator ["@" expr]
                   ["@;" eval]
                   ["@;" runtime]
                   ["@;" common]))
  (test/luxc common))

(host;import java.lang.Integer)

(def: gen-primitive
  (r;Random ls;Synthesis)
  (r;either (r;either (r;either (r/wrap (' []))
                                (r/map code;bool r;bool))
                      (r;either (r/map code;nat r;nat)
                                (r/map code;int r;int)))
            (r;either (r;either (r/map code;deg r;deg)
                                (r/map code;frac r;frac))
                      (r/map code;text (r;text +5)))))

(def: (corresponds? [prediction sample])
  (-> [ls;Synthesis Top] Bool)
  (case prediction
    [_ (#;Tuple #;Nil)]
    (is hostL;unit (:! Text sample))

    (^template [<tag> <type> <test>]
      [_ (<tag> prediction')]
      (case (host;try (<test> prediction' (:! <type> sample)))
        (#e;Success result)
        result

        (#e;Error error)
        false))
    ([#;Bool Bool bool/=]
     [#;Nat  Nat n.=]
     [#;Int  Int i.=]
     [#;Deg  Deg d.=]
     [#;Frac Frac f.=]
     [#;Text Text text/=])

    _
    false
    ))

(context: "Tuples."
  (<| (times +100)
      (do @
        [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2))))
         members (r;list size gen-primitive)]
        (test "Can generate tuple."
              (|> (do meta;Monad<Meta>
                    [sampleI (@;generate (code;tuple members))]
                    (@eval;eval sampleI))
                  (meta;run (init-compiler []))
                  (case> (#e;Success valueG)
                         (let [valueG (:! (Array Top) valueG)]
                           (and (n.= size (array;size valueG))
                                (list;every? corresponds? (list;zip2 members (array;to-list valueG)))))

                         _
                         false))))))

(context: "Variants."
  (<| (times +100)
      (do @
        [num-tags (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2))))
         tag (|> r;nat (:: @ map (n.% num-tags)))
         #let [last? (n.= (n.dec num-tags) tag)]
         member gen-primitive]
        (test "Can generate variant."
              (|> (do meta;Monad<Meta>
                    [runtime-bytecode @runtime;generate
                     sampleI (@;generate (` ((~ (code;nat tag)) (~ (code;bool last?)) (~ member))))]
                    (@eval;eval sampleI))
                  (meta;run (init-compiler []))
                  (case> (#e;Success valueG)
                         (let [valueG (:! (Array Top) valueG)]
                           (and (n.= +3 (array;size valueG))
                                (let [_tag (:! Integer (maybe;assume (array;read +0 valueG)))
                                      _last? (array;read +1 valueG)
                                      _value (:! Top (maybe;assume (array;read +2 valueG)))]
                                  (and (n.= tag (|> _tag host;i2l int-to-nat))
                                       (case _last?
                                         (#;Some _last?')
                                         (and last? (text/= "" (:! Text _last?')))

                                         #;None
                                         (not last?))
                                       (corresponds? [member _value])))))

                         _
                         false))))))