(.require
 [library
  [lux (.except)
   [abstract
    [monad (.only do)]]
   [control
    ["[0]" try]
    [function
     ["[0]" predicate]]
    [concurrency
     ["[0]" async]]]
   [data
    ["[0]" text (.use "[1]#[0]" equivalence)
     ["%" \\format (.only format)]
     [encoding
      ["[0]" utf8]]]
    [collection
     ["[0]" dictionary]
     ["[0]" set]]
    [format
     ["[0]" xml]]]
   [math
    ["[0]" random (.only Random)]]
   [world
    ["[0]" file]
    ["[0]" environment
     ["program" /]
     ["[1]" \\parser]]]
   [test
    ["[0]" unit]
    ["_" property (.only Test)]]]]
 ["[0]" //
  ["@[0]" version]
  ["$/[1]" //
   ["[1][0]" package]
   ["[1][0]" artifact]
   ["[1][0]" dependency
    ["[1]/[0]" resolution]]]]
 [\\program
  ["[0]" / (.only)
   ["/[1]" //
    ["[1][0]" clean]
    ["/[1]" //
     ["[1]" profile]
     ["[1][0]" action]
     ["[1][0]" pom]
     ["[1][0]" package]
     ["[1][0]" artifact (.only)
      ["[1]/[0]" type]]
     ["[1][0]" dependency (.only)
      ["[1]/[0]" resolution]
      ["[1]/[0]" deployment]
      ["[1]/[0]" status]]
     ["[1][0]" repository (.only)
      ["[1]/[0]" origin]
      ["[1]/[0]" local]]]]]])

(def .public test
  Test
  (<| (_.covering /._)
      (do random.monad
        [home (random.alphabetic 5)
         working_directory (random.alphabetic 5)

         dependee_artifact $///artifact.random
         depender_artifact (random.only (predicate.complement
                                         (of ///artifact.equivalence = dependee_artifact))
                                        $///artifact.random)

         [_ dependee_package] $///package.random
         [_ depender_package] $///package.random

         .let [dependee [///dependency.#artifact dependee_artifact
                         ///dependency.#type ///artifact/type.lux_library]
               depender [///dependency.#artifact depender_artifact
                         ///dependency.#type ///artifact/type.lux_library]

               dependee_pom (|> (of ///.monoid identity)
                                (has ///.#identity {.#Some dependee_artifact})
                                ///pom.write
                                try.trusted)
               depender_pom (|> (of ///.monoid identity)
                                (has ///.#identity {.#Some depender_artifact})
                                (has ///.#dependencies (set.of_list ///dependency.hash (list dependee)))
                                ///pom.write
                                try.trusted)
               
               dependee_package (|> dependee_package
                                    (has ///package.#origin {///repository/origin.#Remote ""})
                                    (has ///package.#pom [dependee_pom
                                                          (|> dependee_pom (of xml.codec encoded) (of utf8.codec encoded))
                                                          {///dependency/status.#Unverified}]))
               depender_package (|> depender_package
                                    (has ///package.#origin {///repository/origin.#Remote ""})
                                    (has ///package.#pom [depender_pom
                                                          (|> depender_pom (of xml.codec encoded) (of utf8.codec encoded))
                                                          {///dependency/status.#Unverified}]))

               fs (file.mock (of file.default separator))
               program (program.async (program.mock environment.empty home working_directory))]]
        (in (do async.monad
              [verdict (do ///action.monad
                         [.let [console (@version.echo "")
                                local (///repository/local.repository program fs)]
                          pre (|> ///dependency/resolution.empty
                                  (dictionary.has dependee dependee_package)
                                  (///dependency/deployment.all local))
                          post (|> (of ///.monoid identity)
                                   (has ///.#dependencies (set.of_list ///dependency.hash (list dependee depender)))
                                   (/.do! console local
                                          (list (///repository.mock ($///dependency/resolution.single depender_artifact depender_package)
                                                                    []))
                                          (function (_ url)
                                            (///repository.mock $///dependency/resolution.nope []))))

                          .let [had_dependee_before!
                                (set.member? pre dependee_artifact)

                                lacked_depender_before!
                                (not (set.member? pre depender_artifact))

                                had_dependee_after!
                                (dictionary.key? post dependee)
                                
                                had_depender_after!
                                (dictionary.key? post depender)]]
                         (in (and had_dependee_before!
                                  lacked_depender_before!
                                  
                                  had_dependee_after!
                                  had_depender_after!)))]
              (unit.coverage [/.do!]
                (try.else false verdict)))))))