(.module:
  [lux (#- Type type)
   ["_" test (#+ Test)]
   [abstract
    ["." monad (#+ do)]]
   [control
    ["." try]
    [concurrency
     ["." promise (#+ Promise)]]
    [parser
     ["." environment]]]
   [data
    [binary (#+ Binary)]
    ["." text]
    [format
     [xml (#+ XML)]]
    [collection
     ["." set]
     ["." dictionary]]]
   [math
    ["." random (#+ Random) ("#\." monad)]
    [number
     ["n" nat]]]
   [world
    ["." file]
    ["." program]]]
  [//
   ["@." profile]
   ["@." artifact]
   [//
    [lux
     [data
      ["_." binary]]]]]
  {#program
   ["." /
    ["/#" // #_
     ["#" profile (#+ Profile)]
     ["#." package (#+ Package)]
     ["#." pom]
     ["#." dependency (#+ Dependency)
      ["#/." resolution (#+ Resolution)]]
     ["#." artifact (#+ Artifact)
      ["#/." type (#+ Type)]]
     ["#." repository #_
      ["#/." origin]]]]})

(def: type
  (Random Type)
  ($_ random.either
      (random\wrap //artifact/type.lux_library)
      (random\wrap //artifact/type.jvm_library)))

(def: profile
  (Random [Artifact Profile XML])
  (random.one (function (_ profile)
                (try.to_maybe
                 (do try.monad
                   [pom (//pom.write profile)
                    identity (try.from_maybe (get@ #//.identity profile))]
                   (wrap [identity profile pom]))))
              @profile.random))

(def: content
  (Random Binary)
  (do {! random.monad}
    [content_size (\ ! map (n.% 100) random.nat)]
    (_binary.random content_size)))

(def: package
  (Random [Dependency Package])
  (do {! random.monad}
    [[identity profile pom] ..profile
     type ..type
     content ..content]
    (wrap [{#//dependency.artifact identity
            #//dependency.type type}
           (set@ #//package.origin (#//repository/origin.Remote "") (//package.local pom content))])))

(def: resolution
  (Random Resolution)
  (do {! random.monad}
    [[main_dependency main_package] ..package
     dependencies (|> (//package.dependencies main_package)
                      (\ try.monad map set.to_list)
                      (try.default (list))
                      (monad.map ! (function (_ dependency)
                                     (do !
                                       [pom (random.one (function (_ [identity profile pom])
                                                          (|> profile
                                                              (set@ #//.dependencies (set.new //dependency.hash))
                                                              (set@ #//.identity (#.Some (get@ #//dependency.artifact dependency)))
                                                              //pom.write
                                                              try.to_maybe))
                                                        ..profile)
                                        content ..content]
                                       (wrap [dependency
                                              (set@ #//package.origin (#//repository/origin.Remote "") (//package.local pom content))])))))]
    (wrap (dictionary.from_list //dependency.hash (list& [main_dependency main_package] dependencies)))))

(def: singular
  Test
  (do {! random.monad}
    [[dependency expected_package] ..package
     home (random.ascii/alpha 5)
     working_directory (random.ascii/alpha 5)
     #let [fs (: (file.System Promise)
                 (file.mock (\ file.default separator)))
           program (program.async (program.mock environment.empty home working_directory))]]
    (wrap (do promise.monad
            [wrote! (/.write_one program fs dependency expected_package)
             read! (/.read_one program fs dependency)]
            (_.cover' [/.write_one /.read_one]
                      (<| (try.default false)
                          (do try.monad
                            [_ wrote!
                             actual_package read!]
                            (wrap (\ //package.equivalence =
                                     (set@ #//package.origin (#//repository/origin.Local "") expected_package)
                                     actual_package)))))))))

(def: plural
  Test
  (do {! random.monad}
    [expected ..resolution
     home (random.ascii/alpha 5)
     working_directory (random.ascii/alpha 5)
     #let [fs (: (file.System Promise)
                 (file.mock (\ file.default separator)))
           program (program.async (program.mock environment.empty home working_directory))]]
    (wrap (do promise.monad
            [wrote! (/.write_all program fs expected)
             read! (/.read_all program fs (dictionary.keys expected) //dependency/resolution.empty)]
            (_.cover' [/.write_all /.read_all]
                      (<| (try.default false)
                          (do try.monad
                            [_ wrote!
                             actual read!]
                            (wrap (\ //dependency/resolution.equivalence =
                                     (\ dictionary.functor map
                                        (set@ #//package.origin (#//repository/origin.Local ""))
                                        expected)
                                     actual)))))))))

(def: #export test
  Test
  (<| (_.covering /._)
      ($_ _.and
          ..singular
          ..plural
          )))