## (use "./another" as another)

(jvm/definterface Function
  (: apply (-> [java.lang.Object] java.lang.Object)))

(jvm/defclass Tuple0 java.lang.Object
  [])
(jvm/defclass Tuple1 java.lang.Object
  [[java.lang.Object _1]])
(jvm/defclass Tuple2 java.lang.Object
  [[java.lang.Object _1] [java.lang.Object _2]])
(jvm/defclass Tuple3 java.lang.Object
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3]])
(jvm/defclass Tuple4 java.lang.Object
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]])
(jvm/defclass Tuple5 java.lang.Object
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5]])
(jvm/defclass Tuple6 java.lang.Object
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5] [java.lang.Object _6]])
(jvm/defclass Tuple7 java.lang.Object
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5] [java.lang.Object _6]
   [java.lang.Object _7]])
(jvm/defclass Tuple8 java.lang.Object
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5] [java.lang.Object _6]
   [java.lang.Object _7] [java.lang.Object _8]])

(jvm/defclass Variant java.lang.Object
  [[java.lang.String tag]])
(jvm/defclass Variant0 test2.Variant
  [])
(jvm/defclass Variant1 test2.Variant
  [[java.lang.Object _1]])
(jvm/defclass Variant2 test2.Variant
  [[java.lang.Object _1] [java.lang.Object _2]])
(jvm/defclass Variant3 test2.Variant
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3]])
(jvm/defclass Variant4 test2.Variant
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]])
(jvm/defclass Variant5 test2.Variant
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5]])
(jvm/defclass Variant6 test2.Variant
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5] [java.lang.Object _6]])
(jvm/defclass Variant7 test2.Variant
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5] [java.lang.Object _6]
   [java.lang.Object _7]])
(jvm/defclass Variant8 test2.Variant
  [[java.lang.Object _1] [java.lang.Object _2]
   [java.lang.Object _3] [java.lang.Object _4]
   [java.lang.Object _5] [java.lang.Object _6]
   [java.lang.Object _7] [java.lang.Object _8]])

(def (println x)
  (jvm/invokevirtual java.io.PrintStream "println" [Object]
                     (jvm/getstatic System out) [x]))

(def (++ xs ys)
  (case xs
    #Nil
    ys

    (#Cons x xs*)
    (#Cons x (++ xs* ys))))

(def (template elems)
  (case elems
    #Nil
    elems

    (#Cons head tail)
    (case head
      (#Form (#Cons (#Ident "~") (#Cons unquoted #Nil)))
      (#Cons unquoted (template tail))

      (#Form (#Cons (#Ident "~@") (#Cons spliced #Nil)))
      (#Cons (#Ident "++") (#Cons spliced (template tail)))

      _
      (#Cons head (template tail))
      )))

(def (map f xs)
  (case xs
    #Nil
    #Nil

    (#Cons x xs*)
    (#Cons (f x) (map f xs*))))

(def (convert-list f xs)
  (case xs
    #Nil
    (#Tag "Nil")

    (#Cons x xs*)
    (#Form (#Cons (#Tag "Cons") (#Cons (f x) (#Cons (convert-list f xs*) #Nil))))))

(def (convert token)
  (case token
    (#Tag tag)
    (#Form (#Cons (#Tag "Tag") (#Cons (#Text tag) #Nil)))

    (#Text text)
    (#Form (#Cons (#Tag "Text") (#Cons (#Text text) #Nil)))

    (#Ident ident)
    (#Form (#Cons (#Tag "Ident") (#Cons (#Text ident) #Nil)))

    (#Form elems)
    (#Form (#Cons (#Tag "Form") (#Cons (convert-list convert elems) #Nil)))
    ))

(defmacro (' form)
  (case form
    (#Cons form* #Nil)
    (case form*
      (#Form elems)
      (convert (#Form (template elems)))

      _
      (convert form)
      )))

## Utils
(def (fail* message)
  (#Failure message))

(def (return* state value)
  (#Ok state value))

(def (fail message)
  (lambda [state]
     (#Failure message)))

(def (return value)
  (lambda [state]
     (#Ok state value)))

(def (bind m-value step)
  (lambda [state]
     (let inputs (m-value state)
          (case inputs
            (#Ok ?state ?datum)
            (step ?datum ?state)
            
            _
            inputs))))

## Ideally, this is what I want...
## (exec [yolo lol
##        #let [foo (bar 1 2 3)]
##        #when true]
##   (meme yolo foo))

(def (+ x y)
  (jvm/i+ x y))

(def inc (+ 1))

(def (id x)
  x)

(def (fold f init values)
  (case values
    #Nil
    init
    (#Cons x xs)
    (fold f (f init x) xs)))

(def length (fold (lambda [l x] (inc l)) 0))

(def (rem dividend divisor)
  (jvm/irem dividend divisor))

(def (= x y)
  (jvm/invokevirtual Object "equals" [Object]
                     x [y]))

(def (as-pairs list)
  (case list
    (#Cons x (#Cons y list*))
    (#Cons [x y] (as-pairs list*))

    _
    #Nil))

#( (defmacro (exec tokens)
     (case tokens
       (#Cons (#Tuple steps) (#Cons return #Nil))
       (if (= 0 (rem (length steps) 2))
         (fold (lambda [inner pair]
                  (case pair
                    [label computation]
                    (' (bind (~ computation)
                             (lambda [(~ label)] (~ inner))))))
               return
               (as-pairs steps))
         (#Text "Oh no!")))) )#

## Program
(def (main args)
  (case (' ((~ "Oh yeah...")))
    (#Form (#Cons (#Text text) #Nil))
    (do (println text)
      (println (+ 10 20))
      (println (inc 10))
      (println (jvm/i- 10 20))
      (println (jvm/i* 10 20))
      (println (jvm/i/ 10 2))
      (let list (#Cons 1 (#Cons 2 (#Cons 3 (#Cons 4 (#Cons 5 (#Cons 6 #Nil))))))
           (do (println (fold + 0 list))
             (println (length list))))
      (println (rem 21 6))
      (println (rem 21 7))
      (println (= false false))
      (println (= false true))
      (println (= true false))
      (println (= true true)))
    ))

#( (def (main args)
     (case (' ((~ "Oh yeah...")))
       (#Form (#Cons (#Text text) #Nil))
       (do (:: (:: System out) (println text))
         (:: (:: System out) (println (+ 10 20)))
         (:: (:: System out) (println (inc 10)))
         (:: (:: System out) (println (jvm/i- 10 20)))
         (:: (:: System out) (println (jvm/i* 10 20)))
         (:: (:: System out) (println (jvm/i/ 10 2))))
       ))
   
   (defmacro (::+ pieces)
     (case pieces
       (#Cons init #Nil)
       init

       (#Cons init (#Cons access others))
       (' (::+ (:: (~ init) (~ access)) (~@ others)))
       ))

   (def (main args)
     (if true
       (let f (lambda [x] (lambda [y] (x y)))
            (let g (lambda [x] x)
                 (::+ System out (println (f g "WE'VE GOT CLOSURES!")))))
       (:: (:: System out) (println "FALSE"))))

   (def (main args)
     (if true
       (case (++ (#Cons "Pattern" #Nil) (#Cons "Matching" #Nil))
         (#Cons "Pattern" (#Cons second #Nil))
         (do (:: (:: System out) (println "Branch #1"))
           (:: (:: System out) (println second)))

         (#Cons first (#Cons second #Nil))
         (do (:: (:: System out) (println "Branch #2"))
           (:: (:: System out) (println first))
           (:: (:: System out) (println second))))
       (:: (:: System out) (println "FALSE"))))

   (def (main args)
     (case (template (#Cons (#Cons (#Symbol "~@") (#Cons (#Symbol "Pattern") #Nil)) #Nil)
                     ## (#Cons (#Cons (#Symbol "~") (#Cons (#Symbol "Pattern") #Nil)) #Nil)
                        )
       (#Cons word #Nil)
       (do (:: (:: System out) (println "Branch #1"))
         (:: (:: System out) (println word)))

       (#Cons (#Symbol op) spliced)
       (do (:: (:: System out) (println "Branch #2"))
         (:: (:: System out) (println op)))
       ))

   (def (main args)
     (case (' "YOLO")
       (#Text text)
       (:: (:: System out) (println text))))

   (def (main args)
     (case (' ((~ "TROLOLOL")))
       (#Form (#Cons (#Text text) #Nil))
       (:: (:: System out) (println text))
       ))
   )#