(.using
 [library
  [lux {"-" Module}
   [type {"+" :sharing}]
   ["@" target]
   ["[0]" debug]
   [abstract
    ["[0]" monad {"+" do}]]
   [control
    ["[0]" io {"+" IO io}]
    ["[0]" maybe]
    ["[0]" try {"+" Try}]
    [concurrency
     ["[0]" async {"+" Async} ("[1]#[0]" monad)]]]
   [data
    [binary {"+" Binary}]
    ["[0]" product]
    ["[0]" text
     ["%" format {"+" format}]]
    [collection
     ["[0]" dictionary {"+" Dictionary}]]]
   [time
    ["[0]" instant]]
   ["[0]" world "_"
    ["[0]" file]
    ["[0]" console]
    ["[1]/[0]" program]]
   [tool
    ["[0]" compiler
     ["[0]" phase]
     [default
      ["[0]" platform {"+" Platform}]]
     [language
      ["$" lux
       ["[1]/[0]" program {"+" Program}]
       ["[0]" syntax]
       ["[0]" generation]
       ["[0]" directive]
       ["[0]" analysis
        [macro {"+" Expander}]]
       [phase
        [extension {"+" Extender}]]]]
     [meta
      [packager {"+" Packager}]
      [context {"+" Context}]
      ["[0]" cli {"+" Service}]
      ["[0]" import]
      ["[0]" export]
      ["[0]" cache "_"
       ["[1]" archive]]
      [archive {"+" Archive}
       ["[0]" unit]
       [module
        [descriptor {"+" Module}]]]
      [io
       ["ioW" archive]]]]
    ... ["[0]" interpreter]
    ]]])

(def: (or_crash! failure_description action)
  (All (_ a)
    (-> Text (Async (Try a)) (Async a)))
  (do [! async.monad]
    [?output action]
    (case ?output
      {try.#Failure error}
      (let [report (format text.new_line
                           failure_description text.new_line
                           error text.new_line)]
        (do !
          [_ (with_expansions [<else> (in (debug.log! report))]
               (for [@.js (case console.default
                            {.#None}
                            <else>

                            {.#Some console}
                            (console.write_line report console))]
                    <else>))]
          (io.run! (# world/program.default exit +1))))

      {try.#Success output}
      (in output))))

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

(def: (package! fs host_dependencies [packager package] archive context)
  (-> (file.System Async) (Dictionary file.Path Binary) [Packager file.Path] Archive (Maybe unit.ID) (Async (Try Any)))
  (case (packager host_dependencies archive context)
    {try.#Success content}
    (case content
      {.#Left content}
      (# fs write content package)
      
      {.#Right content}
      (do [! (try.with async.monad)]
        [_ (# fs make_directory package)
         _ (monad.each ! (function (_ [name content])
                           (# fs write content (file.rooted fs package name)))
                       content)]
        (in [])))
    
    {try.#Failure error}
    (# async.monad in {try.#Failure error})))

(def: (load_host_dependencies fs host_dependencies)
  (-> (file.System Async) (List file.Path) (Async (Try (Dictionary file.Path Binary))))
  (do [! (try.with async.monad)]
    []
    (loop [pending host_dependencies
           output (: (Dictionary file.Path Binary)
                     (dictionary.empty text.hash))]
      (case pending
        {.#End}
        (in output)

        {.#Item head tail}
        (do !
          [content (# fs read head)]
          (again tail
                 (dictionary.has head content output)))))))

(with_expansions [<parameters> (as_is anchor expression artifact)]
  (def: .public (compiler lux_compiler file_context
                          expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
                          service
                          packager,package)
    (All (_ <parameters>)
      (-> (-> Any platform.Custom)
          Context
          Expander
          analysis.Bundle
          (IO (Platform <parameters>))
          (generation.Bundle <parameters>)
          (-> phase.Wrapper (directive.Bundle <parameters>))
          (Program expression artifact)
          [Type Type Type]
          (-> phase.Wrapper Extender)
          Service
          [Packager file.Path]
          (Async Any)))
    (do [! async.monad]
      [platform (async.future platform)]
      (case service
        {cli.#Compilation compilation}
        (<| (or_crash! "Compilation failed:")
            ..timed
            (do (try.with async.monad)
              [.let [[compilation_host_dependencies compilation_libraries compilation_compilers compilation_sources compilation_target compilation_module compilation_configuration] compilation]
               import (import.import (the platform.#&file_system platform) compilation_libraries)
               [state archive phase_wrapper] (:sharing [<parameters>]
                                                       (Platform <parameters>)
                                                       platform
                                                       
                                                       (Async (Try [(directive.State+ <parameters>)
                                                                    Archive
                                                                    phase.Wrapper]))
                                                       (:expected (platform.initialize file_context compilation_module expander host_analysis platform generation_bundle host_directive_bundle program anchorT,expressionT,directiveT extender
                                                                                       import compilation_sources compilation_configuration)))
               [archive state] (:sharing [<parameters>]
                                         (Platform <parameters>)
                                         platform
                                         
                                         (Async (Try [Archive (directive.State+ <parameters>)]))
                                         (:expected (platform.compile lux_compiler phase_wrapper import file_context expander platform compilation [archive state])))
               _ (cache.cache! (the platform.#&file_system platform) file_context archive)
               host_dependencies (..load_host_dependencies (the platform.#&file_system platform) compilation_host_dependencies)
               _ (..package! (for [@.old (file.async file.default)
                                   @.jvm (file.async file.default)
                                   ... TODO: Handle this in a safer manner.
                                   ... This would crash if the compiler was run on a browser.
                                   @.js (maybe.trusted file.default)])
                             host_dependencies
                             packager,package
                             archive
                             (try.maybe ($/program.context archive)))]
              (in (debug.log! "Compilation complete!"))))

        {cli.#Export export}
        (<| (or_crash! "Export failed:")
            (do (try.with async.monad)
              [_ (export.export (the platform.#&file_system platform)
                                export)]
              (in (debug.log! "Export complete!"))))
        
        {cli.#Interpretation interpretation}
        ... TODO: Fix the interpreter...
        (undefined)
        ... (<| (or_crash! "Interpretation failed:")
        ...     (do [! async.monad]
        ...       [console (|> console.default
        ...                    async.future
        ...                    (# ! each (|>> try.trusted console.async)))]
        ...       (interpreter.run! (try.with async.monad) console platform interpretation generation_bundle)))
        ))))