(.module:
  [lux #*
   ["@" target]
   ["." host (#+ import:)]
   [abstract
    [monad (#+ do)]]
   [control
    ["." io (#+ IO)]
    ["." try (#+ Try)]
    [parser
     [cli (#+ program:)]]]
   [data
    [text
     ["%" format (#+ format)]]
    [collection
     [array (#+ Array)]
     ["." dictionary]]]
   [world
    ["." file]]
   [target
    [jvm
     ["$t" type]]]
   [tool
    [compiler
     [phase
      ["." macro (#+ Expander)]
      [extension (#+ Phase Bundle Operation Handler Extender)
       ["." analysis #_
        ["#" jvm]]]]
     [default
      ["." platform (#+ Platform)]]]]]
  [program
   ["/" compositor
    ["/." cli]]]
  [luxc
   [lang
    ["." packager]
    [host
     ["_" jvm
      ["$d" def]
      ["$i" inst]]]
    ["." directive #_
     ["#" jvm]]
    [translation
     ["." jvm
      ["." runtime]
      ["." expression]
      ["translation" extension]]]]])

(import: #long java/lang/reflect/Method
  (invoke [java/lang/Object [java/lang/Object]] #try java/lang/Object))

(import: #long (java/lang/Class c)
  (getMethod [java/lang/String [(java/lang/Class java/lang/Object)]] #try java/lang/reflect/Method))

(import: #long java/lang/Object
  (getClass [] (java/lang/Class java/lang/Object)))

(def: _object-class
  (java/lang/Class java/lang/Object)
  (host.class-for java/lang/Object))

(def: _apply2-args
  (Array (java/lang/Class java/lang/Object))
  (|> (host.array (java/lang/Class java/lang/Object) 2)
      (host.array-write 0 _object-class)
      (host.array-write 1 _object-class)))

(def: _apply4-args
  (Array (java/lang/Class java/lang/Object))
  (|> (host.array (java/lang/Class java/lang/Object) 4)
      (host.array-write 0 _object-class)
      (host.array-write 1 _object-class)
      (host.array-write 2 _object-class)
      (host.array-write 3 _object-class)))

(def: #export (expander macro inputs lux)
  Expander
  (do try.monad
    [apply-method (|> macro
                      (:coerce java/lang/Object)
                      (java/lang/Object::getClass)
                      (java/lang/Class::getMethod "apply" _apply2-args))]
    (:coerce (Try (Try [Lux (List Code)]))
             (java/lang/reflect/Method::invoke
              (:coerce java/lang/Object macro)
              (|> (host.array java/lang/Object 2)
                  (host.array-write 0 (:coerce java/lang/Object inputs))
                  (host.array-write 1 (:coerce java/lang/Object lux)))
              apply-method))))

(def: #export platform
  (IO (Platform IO _.Anchor _.Inst _.Definition))
  (do io.monad
    [host jvm.host]
    (wrap {#platform.&monad io.monad
           #platform.&file-system file.system
           #platform.host host
           #platform.phase expression.translate
           #platform.runtime runtime.translate})))

(def: program-class "LuxProgram")

(def: #export (program programI)
  (-> _.Inst _.Definition)
  (let [$Object ($t.class "java.lang.Object" (list))
        nilI runtime.noneI
        num-inputsI (|>> ($i.ALOAD 0) $i.ARRAYLENGTH)
        decI (|>> ($i.int +1) $i.ISUB)
        headI (|>> $i.DUP
                   ($i.ALOAD 0)
                   $i.SWAP
                   $i.AALOAD
                   $i.SWAP
                   $i.DUP_X2
                   $i.POP)
        pairI (|>> ($i.int +2)
                   ($i.ANEWARRAY $Object)
                   $i.DUP_X1
                   $i.SWAP
                   ($i.int +0)
                   $i.SWAP
                   $i.AASTORE
                   $i.DUP_X1
                   $i.SWAP
                   ($i.int +1)
                   $i.SWAP
                   $i.AASTORE)
        consI (|>> ($i.int +1)
                   ($i.string "")
                   $i.DUP2_X1
                   $i.POP2
                   runtime.variantI)
        prepare-input-listI (<| $i.with-label (function (_ @loop))
                                $i.with-label (function (_ @end))
                                (|>> nilI
                                     num-inputsI
                                     ($i.label @loop)
                                     decI
                                     $i.DUP
                                     ($i.IFLT @end)
                                     headI
                                     pairI
                                     consI
                                     $i.SWAP
                                     ($i.GOTO @loop)
                                     ($i.label @end)
                                     $i.POP))
        feed-inputsI ($i.INVOKEVIRTUAL jvm.$Function runtime.apply-method (runtime.apply-signature 1))
        run-ioI (|>> ($i.CHECKCAST jvm.$Function)
                     $i.NULL
                     ($i.INVOKEVIRTUAL jvm.$Function runtime.apply-method (runtime.apply-signature 1)))
        main-type ($t.method [(list ($t.array ($t.class "java.lang.String" (list))))
                              $t.void
                              (list)])]
    [..program-class
     ($d.class #_.V1_6
               #_.Public _.finalC
               ..program-class
               (list) $Object
               (list)
               (|>> ($d.method #_.Public _.staticM "main" main-type
                               (|>> programI
                                    prepare-input-listI
                                    feed-inputsI
                                    run-ioI
                                    $i.RETURN))))]))

(def: extender
  Extender
  ## TODO: Stop relying on coercions ASAP.
  (<| (:coerce Extender)
      (function (@self handler))
      (:coerce Handler)
      (function (@self name phase))
      (:coerce Phase)
      (function (@self parameters))
      (:coerce Operation)
      (function (@self state))
      (:coerce Try)
      try.assume
      (:coerce Try)
      (do try.monad
        [method (|> handler
                    (:coerce java/lang/Object)
                    (java/lang/Object::getClass)
                    (java/lang/Class::getMethod "apply" _apply4-args))]
        (java/lang/reflect/Method::invoke
         (:coerce java/lang/Object handler)
         (|> (host.array java/lang/Object 4)
             (host.array-write 0 (:coerce java/lang/Object name))
             (host.array-write 1 (:coerce java/lang/Object phase))
             (host.array-write 2 (:coerce java/lang/Object parameters))
             (host.array-write 3 (:coerce java/lang/Object state)))
         method))))

(program: [{service /cli.service}]
  (let [(^slots [#/cli.target #/cli.module]) (case service
                                               (#/cli.Compilation configuration) configuration
                                               (#/cli.Interpretation configuration) configuration)
        jar-path (format target (:: file.system separator) "program.jar")]
    (/.compiler @.jvm
                ".jvm"
                ..expander
                analysis.bundle
                ..platform
                translation.bundle
                directive.bundle
                ..program
                ..extender
                service
                [(packager.package ..program-class) jar-path])))