(.using
 [library
  [lux "*"
   ["_" test {"+" Test}]
   [abstract
    [monad {"+" do}]
    [hash {"+" Hash}]
    [\\specification
     ["$[0]" equivalence]
     ["$[0]" monoid]]]
   [control
    [pipe {"+" case>}]
    ["[0]" try]
    [parser
     ["[0]" cli]]]
   [data
    ["[0]" text ("[1]#[0]" equivalence)]
    [collection
     ["[0]" set {"+" Set}]
     ["[0]" dictionary {"+" Dictionary}]]]
   [math
    ["[0]" random {"+" Random} ("[1]#[0]" monad)]
    [number
     ["n" nat]]]]]
 [//
  ["@[0]" artifact]
  ["@[0]" dependency]]
 [\\program
  ["[0]" /
   ["/[1]" // "_"
    ["[1][0]" runtime]
    ["[1][0]" dependency {"+" Dependency}]
    ["[1][0]" format]
    [repository
     [remote {"+" Address}]]]]])

(def: distribution
  (Random /.Distribution)
  (random.or (random#in [])
             (random#in [])))

(def: license
  (Random /.License)
  ($_ random.and
      (random.ascii/alpha 1)
      (random.ascii/alpha 1)
      ..distribution))

(def: scm
  (Random /.SCM)
  (random.ascii/alpha 1))

(def: organization
  (Random /.Organization)
  ($_ random.and
      (random.ascii/alpha 1)
      (random.ascii/alpha 1)))

(def: email
  (Random /.Email)
  (random.ascii/alpha 1))

(def: developer
  (Random /.Developer)
  ($_ random.and
      (random.ascii/alpha 1)
      (random.ascii/alpha 1)
      (random.maybe organization)))

(def: contributor
  (Random /.Contributor)
  ..developer)

(def: (list_of random)
  (All (_ a) (-> (Random a) (Random (List a))))
  (do [! random.monad]
    [size (# ! each (n.% 5) random.nat)]
    (random.list size random)))

(def: (set_of hash random)
  (All (_ a) (-> (Hash a) (Random a) (Random (Set a))))
  (# random.functor each
     (set.of_list hash)
     (..list_of random)))

(def: (dictionary_of key_hash key_random value_random)
  (All (_ k v) (-> (Hash k) (Random k) (Random v) (Random (Dictionary k v))))
  (# random.functor each
     (dictionary.of_list key_hash)
     (..list_of (random.and key_random value_random))))

(def: info
  (Random /.Info)
  ($_ random.and
      (random.maybe (random.ascii/alpha 1))
      (random.maybe ..scm)
      (random.maybe (random.ascii/alpha 1))
      (..list_of ..license)
      (random.maybe ..organization)
      (..list_of ..developer)
      (..list_of ..contributor)
      ))

(def: name
  (Random /.Name)
  (random.ascii/alpha 1))

(def: repository
  (Random Address)
  (random.ascii/alpha 1))

(def: source
  (Random /.Source)
  (random.ascii/alpha 1))

(def: target
  (Random /.Target)
  (random.ascii/alpha 1))

(def: .public random
  (Random /.Profile)
  ($_ random.and
      (..list_of ..name)
      (random.maybe @artifact.random)
      (random.maybe ..info)
      (..set_of text.hash ..repository)
      (..set_of //dependency.hash @dependency.random)
      @dependency.random
      (..set_of text.hash ..source)
      ..target
      (random.maybe (random.ascii/alpha 1))
      (random.maybe (random.ascii/alpha 1))
      (..dictionary_of text.hash (random.ascii/alpha 1) ..repository)
      (random#in //runtime.default_java)
      (random#in //runtime.default_js)
      (random#in //runtime.default_python)
      (random#in //runtime.default_lua)
      (random#in //runtime.default_ruby)
      ))

(def: .public test
  Test
  (<| (_.covering /._)
      (_.for [/.Distribution /.License /.SCM /.Organization
              /.Email /.Developer /.Contributor /.Info
              /.Source /.Target /.Name /.Profile]
             (`` ($_ _.and
                     (_.for [/.equivalence]
                            ($equivalence.spec /.equivalence ..random))
                     (_.for [/.monoid]
                            ($monoid.spec /.equivalence /.monoid ..random))

                     (_.cover [/.default]
                              (text#= "" /.default))
                     (_.cover [/.default_compiler]
                              (|> (# /.monoid identity)
                                  (the /.#compiler)
                                  (same? /.default_compiler)))
                     (_.cover [/.default_target]
                              (|> (# /.monoid identity)
                                  (the /.#target)
                                  (same? /.default_target)))
                     )))))