(.module:
  [library
   [lux (#- Module)
    [type (#+ :share)]
    ["@" target]
    ["." debug]
    [abstract
     [monad (#+ do)]]
    [control
     ["." io (#+ IO io)]
     ["." try (#+ Try)]
     [concurrency
      ["." promise (#+ Promise) ("#\." monad)]]]
    [data
     [binary (#+ Binary)]
     ["." product]
     ["." text
      ["%" format (#+ format)]]
     [collection
      ["." dictionary]
      ["." row (#+ Row)]]]
    [time
     ["." instant]]
    ["." world #_
     ["." file]
     ["#/." program]
     ## ["." console]
     ]
    [tool
     [compiler
      ["." phase]
      [default
       ["." platform (#+ Platform)]]
      [language
       ["$" lux
        ["#/." program (#+ Program)]
        ["." syntax]
        ["." analysis
         [macro (#+ Expander)]]
        ["." generation (#+ Buffer Context)]
        ["." directive]
        [phase
         [extension (#+ Extender)]]]]
      [meta
       [packager (#+ Packager)]
       [archive (#+ Archive)
        [descriptor (#+ Module)]]
       [cache
        ["." dependency]]
       [io
        ["ioW" archive]]]]
     ## ["." interpreter]
     ]]]
  ["." / #_
   ["#." cli (#+ Service)]
   ["#." static (#+ Static)]
   ["#." export]
   ["#." import]])

(def: (or_crash! failure_description action)
  (All [a]
    (-> Text (Promise (Try a)) (Promise a)))
  (do promise.monad
    [?output action]
    (case ?output
      (#try.Failure error)
      (exec (debug.log! (format text.new_line
                                failure_description text.new_line
                                error text.new_line))
        (io.run (\ world/program.default exit +1)))

      (#try.Success output)
      (wrap output))))

(def: (timed process)
  (All [a]
    (-> (Promise (Try a)) (Promise (Try a))))
  (do promise.monad
    [#let [start (io.run instant.now)]
     output process
     #let [_ ("lux io log" (|> (io.run instant.now)
                               (instant.span start)
                               %.duration
                               (format "Duration: ")))]]
    (wrap output)))

(def: (package! fs [packager package] static archive context)
  (-> (file.System Promise) [Packager file.Path] Static Archive Context (Promise (Try Any)))
  (case (packager archive context)
    (#try.Success content)
    (\ fs write content package)
    
    (#try.Failure error)
    (\ promise.monad wrap (#try.Failure error))))

(with_expansions [<parameters> (as_is anchor expression artifact)]
  (def: #export (compiler static
                          expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
                          service
                          packager,package)
    (All [<parameters>]
      (-> Static
          Expander
          analysis.Bundle
          (IO (Platform <parameters>))
          (generation.Bundle <parameters>)
          (-> platform.Phase_Wrapper (directive.Bundle <parameters>))
          (Program expression artifact)
          [Type Type Type]
          (-> platform.Phase_Wrapper Extender)
          Service
          [Packager file.Path]
          (Promise Any)))
    (do {! promise.monad}
      [platform (promise.future platform)]
      (case service
        (#/cli.Compilation compilation)
        (<| (or_crash! "Compilation failed:")
            ..timed
            (do (try.with promise.monad)
              [#let [[compilation_sources compilation_libraries compilation_target compilation_module] compilation]
               import (/import.import (get@ #platform.&file_system platform) compilation_libraries)
               [state archive] (:share [<parameters>]
                                       (Platform <parameters>)
                                       platform
                                       
                                       (Promise (Try [(directive.State+ <parameters>)
                                                      Archive]))
                                       (:assume (platform.initialize static compilation_module expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
                                                                     import compilation_sources)))
               [archive state] (:share [<parameters>]
                                       (Platform <parameters>)
                                       platform
                                       
                                       (Promise (Try [Archive (directive.State+ <parameters>)]))
                                       (:assume (platform.compile import static expander platform compilation [archive state])))
               _ (ioW.freeze (get@ #platform.&file_system platform) static archive)
               program_context (promise\wrap ($/program.context archive))
               _ (..package! (for {@.old (file.async file.default)
                                   @.jvm (file.async file.default)
                                   @.js file.default})
                             packager,package
                             static
                             archive
                             program_context)]
              (wrap (debug.log! "Compilation complete!"))))

        (#/cli.Export export)
        (<| (or_crash! "Export failed:")
            (do (try.with promise.monad)
              [_ (/export.export (get@ #platform.&file_system platform)
                                 export)]
              (wrap (debug.log! "Export complete!"))))
        
        (#/cli.Interpretation interpretation)
        ## TODO: Fix the interpreter...
        (undefined)
        ## (<| (or_crash! "Interpretation failed:")
        ##     (do {! promise.monad}
        ##       [console (|> console.default
        ##                    promise.future
        ##                    (\ ! map (|>> try.assume console.async)))]
        ##       (interpreter.run (try.with promise.monad) console platform interpretation generation_bundle)))
        ))))