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

(def .public good_shell
  (-> Any (Shell IO))
  (shell.mock
   (function (_ [actual_environment actual_working_directory actual_command actual_arguments])
     {try.#Success
      (is (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
      (is (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
      (is (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_fail 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.alphabetic 5)
     .let [js_compiler [///dependency.#artifact [///artifact.#group /.lux_group
                                                 ///artifact.#name /.js_lux_name
                                                 ///artifact.#version lux_version]
                        ///dependency.#type ///artifact/type.js_library]]]
    (`` (all random.either
             (in js_compiler)
             (,, (with_template [<compiler>]
                   [(in [///dependency.#artifact [///artifact.#group /.lux_group
                                                  ///artifact.#name <compiler>
                                                  ///artifact.#version lux_version]
                         ///dependency.#type ///artifact/type.lux_library])]

                   [/.jvm_lux_name]
                   [/.python_lux_name]
                   [/.lua_lux_name]
                   [/.ruby_lux_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.alphabetic 5)
         last_error (random.alphabetic 5)
         .let [fs (file.mock (at file.default separator))
               shell (shell.async (..good_shell []))]
         program (random.alphabetic 5)
         target (random.alphabetic 5)
         home (random.alphabetic 5)
         working_directory (random.alphabetic 5)
         .let [empty_profile (is Profile
                                 (at ///.monoid identity))
               with_target (is (-> Profile Profile)
                               (has ///.#target target))
               with_program (is (-> Profile Profile)
                                (has ///.#program {.#Some program}))
               
               profile (|> empty_profile
                           with_program
                           with_target)]]
        (all _.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))]
                   (_.coverage' [/.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)]
                   (_.coverage' [/.Lux /.no_available_lux]
                     (case outcome
                       {try.#Success _}
                       false

                       {try.#Failure error}
                       (exception.match? /.no_available_lux 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
                                          (has ///.#lux compiler profile))
                                 start (at console read_line [])
                                 end (at console read_line [])]
                                (in (and (text#= /.start start)
                                         (text#= /.success end))))]
                     (_.coverage' [/.do!
                                   /.lux_group
                                   /.jvm_lux_name
                                   /.js_lux_name
                                   /.python_lux_name
                                   /.lua_lux_name
                                   /.ruby_lux_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
                                          (has ///.#lux compiler profile))
                                 start (at console read_line [])
                                 end (at console read_line [])]
                                (in (and (text#= /.start start)
                                         (text#= /.failure end))))]
                     (_.coverage' [/.failure]
                       (try.else false verdict)))))
             (do !
               [expected/0 (random.alphabetic 5)
                expected/1 (random.alphabetic 5)
                expected/2 (random.alphabetic 5)]
               (`` (all _.and
                        (,, (with_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 (at console read_line [])
                                                   actual/1 (at console read_line [])
                                                   actual/2 (at console read_line [])
                                                   end! (|> (at console read_line [])
                                                            (at ! each (|>> (pipe.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!)))]
                                       (_.coverage' [<log!>]
                                         (try.else false verdict)))))]

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