(.module:
  [lux (#- Module)
   ["@" target (#+ Host)]
   [abstract
    ["." monad (#+ do)]]
   [control
    ["." try (#+ Try)]
    ["ex" exception (#+ exception:)]]
   [data
    [binary (#+ Binary)]
    ["." product]
    ["." text ("#@." hash)
     ["%" format (#+ format)]]
    [collection
     ["." list ("#@." functor)]
     ["." dictionary]
     ["." set]
     ["." row ("#@." functor)]]]
   ["." macro]
   [world
    ["." file]]]
  ["." // #_
   ["/#" // (#+ Instancer)
    ["#." phase]
    [language
     [lux
      ["#." version]
      ["#." syntax (#+ Aliases)]
      ["#." analysis
       [macro (#+ Expander)]
       ["#/." evaluation]]
      ["#." synthesis]
      ["#." directive (#+ Requirements)]
      ["#." generation]
      [phase
       [".P" analysis
        ["." module]]
       [".P" synthesis]
       [".P" directive]
       ["." extension (#+ Extender)
        [".E" analysis]
        [".E" synthesis]
        [directive
         [".D" lux]]]]]]
    [meta
     [archive (#+ Archive)
      ["." signature]
      ["." key (#+ Key)]
      ["." descriptor (#+ Module)]
      ["." artifact]
      ["." document]]]]])

(def: #export (info host)
  (-> Text Info)
  {#.target host
   #.version ///version.version
   #.mode #.Build})

(def: #export (state target module expander host-analysis host generate generation-bundle host-directive-bundle program extender)
  (All [anchor expression directive]
    (-> Host
        Module
        Expander
        ///analysis.Bundle
        (///generation.Host expression directive)
        (///generation.Phase anchor expression directive)
        (///generation.Bundle anchor expression directive)
        (///directive.Bundle anchor expression directive)
        (-> expression directive)
        Extender
        (///directive.State+ anchor expression directive)))
  (let [synthesis-state [synthesisE.bundle ///synthesis.init]
        generation-state [generation-bundle (///generation.state host module)]
        eval (///analysis/evaluation.evaluator expander synthesis-state generation-state generate)
        analysis-state [(analysisE.bundle eval host-analysis)
                        (///analysis.state (..info target) host)]]
    [(dictionary.merge (luxD.bundle expander host-analysis program extender)
                       host-directive-bundle)
     {#///directive.analysis {#///directive.state analysis-state
                              #///directive.phase (analysisP.phase expander)}
      #///directive.synthesis {#///directive.state synthesis-state
                               #///directive.phase synthesisP.phase}
      #///directive.generation {#///directive.state generation-state
                                #///directive.phase generate}}]))

(type: Reader
  (-> Source (Either [Source Text] [Source Code])))

(def: (reader current-module aliases [cursor offset source-code])
  (-> Module Aliases Source (///analysis.Operation Reader))
  (function (_ [bundle state])
    (#try.Success [[bundle state]
                   (///syntax.parse current-module aliases ("lux text size" source-code))])))

(def: (read source reader)
  (-> Source Reader (///analysis.Operation [Source Code]))
  (function (_ [bundle compiler])
    (case (reader source)
      (#.Left [source' error])
      (#try.Failure error)

      (#.Right [source' output])
      (let [[cursor _] output]
        (#try.Success [[bundle (|> compiler
                                   (set@ #.source source')
                                   (set@ #.cursor cursor))]
                       [source' output]])))))

(type: (Operation a)
  (All [anchor expression directive]
    (///directive.Operation anchor expression directive a)))

(def: (begin dependencies hash input)
  (-> (List Module) Nat ///.Input
      (All [anchor expression directive]
        (///directive.Operation anchor expression directive
                                [Source (///generation.Buffer directive)])))
  (///directive.lift-analysis
   (do ///phase.monad
     [#let [module (get@ #///.module input)]
      _ (module.create hash module)
      _ (///analysis.set-current-module module)
      _ (monad.map @ module.import dependencies)
      #let [source (///analysis.source (get@ #///.module input) (get@ #///.code input))]
      _ (///analysis.set-source-code source)]
     (wrap [source ///generation.empty-buffer]))))

(def: (end module)
  (-> Module
      (All [anchor expression directive]
        (///directive.Operation anchor expression directive [.Module (///generation.Buffer directive)])))
  (do ///phase.monad
    [_ (///directive.lift-analysis
        (module.set-compiled module))
     analysis-module (<| (: (Operation .Module))
                         ///directive.lift-analysis
                         extension.lift
                         macro.current-module)
     final-buffer (///directive.lift-generation
                   ///generation.buffer)]
    (wrap [analysis-module final-buffer])))

## TODO: Inline ASAP
(def: (get-current-buffer old-buffer)
  (All [directive]
    (-> (///generation.Buffer directive)
        (All [anchor expression]
          (///directive.Operation anchor expression directive
                                  (///generation.Buffer directive)))))
  (///directive.lift-generation
   ///generation.buffer))

## TODO: Inline ASAP
(def: (process-directive archive expander pre-buffer code)
  (All [directive]
    (-> Archive Expander (///generation.Buffer directive) Code
        (All [anchor expression]
          (///directive.Operation anchor expression directive
                                  [Requirements (///generation.Buffer directive)]))))
  (do ///phase.monad
    [_ (///directive.lift-generation
        (///generation.set-buffer pre-buffer))
     requirements (let [execute! (directiveP.phase expander)]
                    (execute! archive code))
     post-buffer (..get-current-buffer pre-buffer)]
    (wrap [requirements post-buffer])))

(def: (iteration archive expander reader source pre-buffer)
  (All [directive]
    (-> Archive Expander Reader Source (///generation.Buffer directive)
        (All [anchor expression]
          (///directive.Operation anchor expression directive
                                  [Source Requirements (///generation.Buffer directive)]))))
  (do ///phase.monad
    [[source code] (///directive.lift-analysis
                    (..read source reader))
     [requirements post-buffer] (process-directive archive expander pre-buffer code)]
    (wrap [source requirements post-buffer])))

(def: (iterate archive expander module source pre-buffer aliases)
  (All [directive]
    (-> Archive Expander Module Source (///generation.Buffer directive) Aliases
        (All [anchor expression]
          (///directive.Operation anchor expression directive
                                  (Maybe [Source Requirements (///generation.Buffer directive)])))))
  (do ///phase.monad
    [reader (///directive.lift-analysis
             (..reader module aliases source))]
    (function (_ state)
      (case (///phase.run' state (..iteration archive expander reader source pre-buffer))
        (#try.Success [state source&requirements&buffer])
        (#try.Success [state (#.Some source&requirements&buffer)])

        (#try.Failure error)
        (if (ex.match? ///syntax.end-of-file error)
          (#try.Success [state #.None])
          (ex.with-stack ///.cannot-compile module (#try.Failure error)))))))

(def: (default-dependencies prelude input)
  (-> Module ///.Input (List Module))
  (if (text@= prelude (get@ #///.module input))
    (list)
    (list prelude)))

(def: module-aliases
  (-> .Module Aliases)
  (|>> (get@ #.module-aliases) (dictionary.from-list text.hash)))

(def: #export (compiler expander prelude write-directive)
  (All [anchor expression directive]
    (-> Expander Module (-> directive Binary)
        (Instancer (///directive.State+ anchor expression directive) .Module)))
  (let [execute! (directiveP.phase expander)]
    (function (_ key parameters input)
      (let [dependencies (default-dependencies prelude input)]
        {#///.dependencies dependencies
         #///.process (function (_ state archive)
                        (do try.monad
                          [#let [hash (text@hash (get@ #///.code input))]
                           [state [source buffer]] (<| (///phase.run' state)
                                                       (..begin dependencies hash input))
                           #let [module (get@ #///.module input)]]
                          (loop [iteration (<| (///phase.run' state)
                                               (..iterate archive expander module source buffer ///syntax.no-aliases))]
                            (do @
                              [[state ?source&requirements&temporary-buffer] iteration]
                              (case ?source&requirements&temporary-buffer
                                #.None
                                (do @
                                  [[state [analysis-module final-buffer]] (///phase.run' state (..end module))
                                   #let [descriptor {#descriptor.hash hash
                                                     #descriptor.name module
                                                     #descriptor.file (get@ #///.file input)
                                                     #descriptor.references (set.from-list text.hash dependencies)
                                                     #descriptor.state #.Compiled
                                                     #descriptor.registry artifact.empty}]]
                                  (wrap [state
                                         (#.Right [[descriptor (document.write key analysis-module)]
                                                   (|> final-buffer
                                                       (row@map (function (_ [name directive])
                                                                  [(product.right name)
                                                                   (write-directive directive)])))])]))

                                (#.Some [source requirements temporary-buffer])
                                (wrap [state
                                       (#.Left {#///.dependencies (|> requirements
                                                                      (get@ #///directive.imports)
                                                                      (list@map product.left))
                                                #///.process (function (_ state archive)
                                                               (recur (<| (///phase.run' state)
                                                                          (do ///phase.monad
                                                                            [analysis-module (<| (: (Operation .Module))
                                                                                                 ///directive.lift-analysis
                                                                                                 extension.lift
                                                                                                 macro.current-module)
                                                                             _ (///directive.lift-generation
                                                                                (///generation.set-buffer temporary-buffer))
                                                                             _ (monad.map @ (execute! archive) (get@ #///directive.referrals requirements))
                                                                             temporary-buffer (..get-current-buffer temporary-buffer)]
                                                                            (..iterate archive expander module source temporary-buffer (..module-aliases analysis-module))))))})])
                                )))))}))))

(def: #export key
  (Key .Module)
  (key.key {#signature.name (name-of ..compiler)
            #signature.version ///version.version}
           (module.new 0)))