(.require
 [library
  [lux (.except)
   ["_" test (.only Test)]
   [abstract
    [monad (.only do)]
    [\\specification
     ["$[0]" equivalence]
     ["$[0]" order]
     ["$[0]" enum]
     ["$[0]" codec]]]
   [control
    ["[0]" try (.use "[1]#[0]" functor)]
    ["[0]" exception]]
   [data
    ["[0]" text
     ["%" \\format (.only format)]
     ["<[1]>" \\parser]]]
   [math
    ["[0]" random (.only Random)]
    [number
     ["n" nat]
     ["i" int]]]]]
 [\\library
  ["[0]" /]])

(def .public test
  Test
  (<| (_.covering /._)
      (_.for [/.Date])
      (all _.and
           (_.for [/.equivalence]
                  ($equivalence.spec /.equivalence random.date))
           (_.for [/.order]
                  ($order.spec /.order random.date))
           (_.for [/.enum]
                  ($enum.spec /.enum random.date))
           (_.for [/.codec]
                  ($codec.spec /.equivalence /.codec random.date))

           (do random.monad
             [expected random.date]
             (_.coverage [/.date /.year /.month /.day_of_month]
               (|> (/.date (/.year expected)
                           (/.month expected)
                           (/.day_of_month expected))
                   (try#each (at /.equivalence = expected))
                   (try.else false))))
           (do random.monad
             [expected random.date]
             (_.coverage [/.invalid_day]
               (case (/.date (/.year expected)
                             (/.month expected)
                             (n.+ 31 (/.day_of_month expected)))
                 {try.#Failure error}
                 (exception.match? /.invalid_day error)
                 
                 {try.#Success _}
                 false)))
           (do random.monad
             [expected random.date]
             (_.coverage [/.days /.of_days]
               (|> expected
                   /.days
                   /.of_days
                   (at /.equivalence = expected))))
           (_.coverage [/.epoch]
             (|> /.epoch
                 /.days
                 (i.= +0)))
           (do random.monad
             [expected random.date]
             (_.coverage [/.parser]
               (|> (at /.codec encoded expected)
                   (<text>.result /.parser)
                   (try#each (at /.equivalence = expected))
                   (try.else false))))
           (do [! random.monad]
             [year (at ! each (|>> (n.% 10,000) ++)
                       random.nat)
              month (at ! each (|>> (n.% 10) (n.+ 13))
                        random.nat)
              day (at ! each (|>> (n.% 10) (n.+ 10))
                      random.nat)
              .let [input (format (%.nat year)
                                  "-" (%.nat month)
                                  "-" (%.nat day))]]
             (_.coverage [/.invalid_month]
               (case (<text>.result /.parser input)
                 {try.#Failure error}
                 (exception.match? /.invalid_month error)
                 
                 {try.#Success _}
                 false)))
           )))