(.module:
  [library
   [lux #*
    ["_" test (#+ Test)]
    [abstract
     [monad (#+ do)]]
    [control
     [pipe (#+ case>)]
     [io (#+ IO)]
     ["." try]
     ["." exception]
     [concurrency
      ["." async (#+ Async)]]
     [parser
      ["." environment]]]
    [data
     ["." text ("#\." equivalence)]
     [collection
      ["." dictionary]]]
    [math
     ["." random (#+ Random)]]
    [world
     ["." file]
     ["." shell (#+ Shell)]
     ["." program]]]]
  ["." // #_
   ["@." version]
   ["$/#" // #_
    ["#." package]]]
  [\\program
   ["." /
    ["//#" /// #_
     ["#" profile (#+ Profile)]
     ["#." action]
     ["#." artifact
      ["#/." type]]
     ["#." dependency (#+ Dependency)
      ["#/." 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_error 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_error 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)
                              (set@ #///.target target))
               with_program (: (-> Profile Profile)
                               (set@ #///.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
                                         (set@ #///.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
                                         (set@ #///.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 [])
                                                          (\ ! map (|>> (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!]
                            ))
                      )))
            ))))