(.module:
  [library
   [lux "*"
    ["_" test {"+" Test}]
    [abstract
     [monad {"+" do}]]
    [control
     [pipe {"+" case>}]
     [io {"+" IO}]
     ["[0]" try]
     ["[0]" exception]
     [concurrency
      ["[0]" async {"+" Async}]]
     [parser
      ["[0]" environment]]]
    [data
     ["[0]" text ("[1]#[0]" equivalence)]
     [collection
      ["[0]" dictionary]]]
    [math
     ["[0]" random {"+" Random}]]
    [world
     ["[0]" file]
     ["[0]" shell {"+" Shell}]
     ["[0]" program]]]]
  ["[0]" // "_"
   ["@[0]" version]
   ["$/[1]" // "_"
    ["[1][0]" package]]]
  [\\program
   ["[0]" /
    ["//[1]" /// "_"
     ["[1]" profile {"+" Profile}]
     ["[1][0]" action]
     ["[1][0]" artifact
      ["[1]/[0]" type]]
     ["[1][0]" dependency {"+" Dependency}
      ["[1]/[0]" resolution {"+" Resolution}]]]]])

(def: .public good_shell
  (-> Any (Shell IO))
  (shell.mock
   (function (_ [actual_environment actual_working_directory actual_command actual_arguments])
     {try.#Success
      (: (shell.Mock [])
         (implementation
          (def: (on_read state)
            (exception.except shell.no_more_output []))
          (def: (on_fail state)
            (exception.except shell.no_more_output []))
          (def: (on_write input state)
            {try.#Failure "on_write"})
          (def: (on_destroy state)
            {try.#Failure "on_destroy"})
          (def: (on_await state)
            {try.#Success [state shell.normal]})))})))

(def: .public bad_shell
  (-> Any (Shell IO))
  (shell.mock
   (function (_ [actual_environment actual_working_directory actual_command actual_arguments])
     {try.#Success
      (: (shell.Mock [])
         (implementation
          (def: (on_read state)
            (exception.except shell.no_more_output []))
          (def: (on_fail state)
            (exception.except shell.no_more_output []))
          (def: (on_write input state)
            {try.#Failure "on_write"})
          (def: (on_destroy state)
            {try.#Failure "on_destroy"})
          (def: (on_await state)
            {try.#Success [state shell.error]})))})))

(def: .public (reader_shell error?)
  (-> Bit (-> (List Text) (Shell IO)))
  (shell.mock
   (function (_ [actual_environment actual_working_directory actual_command actual_arguments])
     {try.#Success
      (: (shell.Mock (List Text))
         (implementation
          (def: (on_read state)
            (if error?
              (exception.except shell.no_more_output [])
              (case state
                {.#Item head tail}
                {try.#Success [tail head]}
                
                {.#End}
                (exception.except shell.no_more_output []))))
          (def: (on_error state)
            (if error?
              (case state
                {.#Item head tail}
                {try.#Success [tail head]}
                
                {.#End}
                (exception.except shell.no_more_output []))
              (exception.except shell.no_more_output [])))
          (def: (on_write input state)
            {try.#Failure "on_write"})
          (def: (on_destroy state)
            {try.#Failure "on_destroy"})
          (def: (on_await state)
            {try.#Success [state shell.error]})))})))

(def: compiler
  (Random Dependency)
  (do random.monad
    [lux_version (random.ascii/alpha 5)
     .let [js_compiler [///dependency.#artifact [///artifact.#group /.lux_group
                                                 ///artifact.#name /.js_compiler_name
                                                 ///artifact.#version lux_version]
                        ///dependency.#type ///artifact/type.js_library]]]
    (`` ($_ random.either
            (in js_compiler)
            (~~ (template [<compiler>]
                  [(in [///dependency.#artifact [///artifact.#group /.lux_group
                                                 ///artifact.#name <compiler>
                                                 ///artifact.#version lux_version]
                        ///dependency.#type ///artifact/type.lux_library])]

                  [/.jvm_compiler_name]
                  [/.python_compiler_name]
                  [/.lua_compiler_name]
                  [/.ruby_compiler_name]
                  ))))))

(def: .public resolution
  (Random [Dependency Resolution])
  (do random.monad
    [dependency ..compiler
     [_ package] $///package.random]
    (in [dependency
         (|> ///dependency/resolution.empty
             (dictionary.has dependency package))])))

(def: .public test
  Test
  (<| (_.covering /._)
      (do [! random.monad]
        [last_read (random.ascii/alpha 5)
         last_error (random.ascii/alpha 5)
         .let [fs (file.mock (# file.default separator))
               shell (shell.async (..good_shell []))]
         program (random.ascii/alpha 5)
         target (random.ascii/alpha 5)
         home (random.ascii/alpha 5)
         working_directory (random.ascii/alpha 5)
         .let [empty_profile (: Profile
                                (# ///.monoid identity))
               with_target (: (-> Profile Profile)
                              (with@ ///.#target target))
               with_program (: (-> Profile Profile)
                               (with@ ///.#program {.#Some program}))
               
               profile (|> empty_profile
                           with_program
                           with_target)]]
        ($_ _.and
            (in (do async.monad
                  [outcome (/.do! (@version.echo "") (program.async (program.mock environment.empty home working_directory)) fs shell ///dependency/resolution.empty
                                  (with_target empty_profile))]
                  (_.cover' [/.no_specified_program]
                            (case outcome
                              {try.#Success _}
                              false

                              {try.#Failure error}
                              (exception.match? /.no_specified_program error)))))
            (in (do async.monad
                  [outcome (/.do! (@version.echo "") (program.async (program.mock environment.empty home working_directory)) fs shell ///dependency/resolution.empty profile)]
                  (_.cover' [/.Compiler /.no_available_compiler]
                            (case outcome
                              {try.#Success _}
                              false

                              {try.#Failure error}
                              (exception.match? /.no_available_compiler error)))))
            (do !
              [.let [console (@version.echo "")]
               [compiler resolution] ..resolution]
              (in (do async.monad
                    [verdict (do ///action.monad
                               [_ (/.do! console (program.async (program.mock environment.empty home working_directory))
                                         fs shell resolution
                                         (with@ ///.#compiler compiler profile))
                                start (# console read_line [])
                                end (# console read_line [])]
                               (in (and (text#= /.start start)
                                        (text#= /.success end))))]
                    (_.cover' [/.do!
                               /.lux_group
                               /.jvm_compiler_name
                               /.js_compiler_name
                               /.python_compiler_name
                               /.lua_compiler_name
                               /.ruby_compiler_name
                               /.start
                               /.success]
                              (try.else false verdict)))))
            (do !
              [.let [console (@version.echo "")]
               [compiler resolution] ..resolution]
              (in (do async.monad
                    [verdict (do ///action.monad
                               [_ (/.do! console (program.async (program.mock environment.empty home working_directory))
                                         fs (shell.async (..bad_shell [])) resolution
                                         (with@ ///.#compiler compiler profile))
                                start (# console read_line [])
                                end (# console read_line [])]
                               (in (and (text#= /.start start)
                                        (text#= /.failure end))))]
                    (_.cover' [/.failure]
                              (try.else false verdict)))))
            (do !
              [expected/0 (random.ascii/alpha 5)
               expected/1 (random.ascii/alpha 5)
               expected/2 (random.ascii/alpha 5)]
              (`` ($_ _.and
                      (~~ (template [<error?> <log!>]
                            [(let [console (@version.echo "")
                                   shell (|> (list expected/0 expected/1 expected/2)
                                             (..reader_shell <error?>)
                                             shell.async)]
                               (in (do [! async.monad]
                                     [verdict (do ///action.monad
                                                [process (shell [environment.empty working_directory "" (list "")])
                                                 _ (<log!> console process)
                                                 actual/0 (# console read_line [])
                                                 actual/1 (# console read_line [])
                                                 actual/2 (# console read_line [])
                                                 end! (|> (# console read_line [])
                                                          (# ! each (|>> (case> {try.#Failure error}
                                                                                true
                                                                                
                                                                                {try.#Success _}
                                                                                false)
                                                                         {try.#Success})))]
                                                (in (and (text#= expected/0 actual/0)
                                                         (text#= expected/1 actual/1)
                                                         (text#= expected/2 actual/2)
                                                         end!)))]
                                     (_.cover' [<log!>]
                                               (try.else false verdict)))))]

                            [#0 /.log_output!]
                            [#1 /.log_error!]
                            ))
                      )))
            ))))