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

(def: #export 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.throw shell.no_more_output []))
          (def: (on_error state)
            (exception.throw 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: #export 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.throw shell.no_more_output []))
          (def: (on_error state)
            (exception.throw 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
  (do random.monad
    [lux_version (random.ascii/alpha 5)
     #let [jvm_compiler {#///dependency.artifact {#///artifact.group /.lux_group
                                                  #///artifact.name /.jvm_compiler_name
                                                  #///artifact.version lux_version}
                         #///dependency.type ///artifact/type.lux_library}
           js_compiler {#///dependency.artifact {#///artifact.group /.lux_group
                                                 #///artifact.name /.js_compiler_name
                                                 #///artifact.version lux_version}
                        #///dependency.type ///artifact/type.lux_library}]]
    (random.either (wrap jvm_compiler)
                   (wrap js_compiler))))

(def: #export resolution
  (do random.monad
    [dependency ..compiler
     [_ package] $///package.random]
    (wrap (|> ///dependency/resolution.empty
              (dictionary.put dependency package)))))

(def: #export 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
            (wrap (do promise.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)))))
            (wrap (do promise.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 "")]
               resolution ..resolution]
              (wrap (do promise.monad
                      [verdict (do ///action.monad
                                 [_ (/.do! console (program.async (program.mock environment.empty home working_directory)) fs shell resolution profile)
                                  start (\ console read_line [])
                                  end (\ console read_line [])]
                                 (wrap (and (text\= /.start start)
                                            (text\= /.success end))))]
                      (_.cover' [/.do!
                                 /.lux_group /.jvm_compiler_name /.js_compiler_name
                                 /.start /.success]
                                (try.default false verdict)))))
            (do !
              [#let [console (@version.echo "")]
               resolution ..resolution]
              (wrap (do promise.monad
                      [verdict (do ///action.monad
                                 [_ (/.do! console (program.async (program.mock environment.empty home working_directory)) fs (shell.async (..bad_shell [])) resolution profile)
                                  start (\ console read_line [])
                                  end (\ console read_line [])]
                                 (wrap (and (text\= /.start start)
                                            (text\= /.failure end))))]
                      (_.cover' [/.failure]
                                (try.default false verdict)))))
            ))))