(.require
 [library
  [lux (.except)
   [abstract
    [monad (.only do)]]
   [control
    ["[0]" io (.only IO)]
    ["[0]" maybe (.use "[1]#[0]" functor)]
    ["[0]" try (.use "[1]#[0]" monad)]
    ["[0]" exception]
    ["[0]" function]]
   [data
    ["[0]" binary (.use "[1]#[0]" equivalence)]
    ["[0]" text (.use "[1]#[0]" equivalence)
     ["%" \\format (.only format)]
     [encoding
      ["[0]" utf8]]]
    [collection
     ["[0]" dictionary]]]
   [math
    ["[0]" random (.only Random)]]
   [world
    [net (.only URL)
     ["[0]" http
      ["[1]" client]
      ["[1]/[0]" status]
      ["@[1]" /]]]]
   [test
    ["_" property (.only Test)]]]]
 [\\program
  ["[0]" / (.only)
   ["/[1]" //
    ["[1][0]" identity]]]])

(def (url_body url)
  (-> URL (@http.Body IO))
  (let [url (of utf8.codec encoded url)]
    (function (_ _)
      (io.io {try.#Success [(binary.size url) url]}))))

(def (good_http user password)
  (-> //identity.User //identity.Password (http.Client IO))
  (implementation
   (def (request method url headers input)
     (with_expansions [<failure> [http/status.bad_request
                                  [@http.#headers (http.headers (list))
                                   @http.#body (..url_body "")]]]
       (<| io.io
           {try.#Success}
           (if (|> headers
                   (dictionary.value "User-Agent")
                   (maybe#each (same? /.user_agent))
                   (maybe.else false))
             (when [method input]
               [{@http.#Get} {.#None}]
               [http/status.ok
                [@http.#headers (http.headers (list))
                 @http.#body (..url_body url)]]
               
               [{@http.#Put} {.#Some input}]
               (if (|> headers
                       (dictionary.value "Authorization")
                       (maybe#each (text#= (//identity.basic_auth user password)))
                       (maybe.else false))
                 [http/status.created
                  [@http.#headers (http.headers (list))
                   @http.#body (..url_body url)]]
                 <failure>)
               
               _
               <failure>)
             <failure>))))))

(def bad_http
  (http.Client IO)
  (implementation
   (def (request method url headers input)
     (<| io.io
         {try.#Success}
         [http/status.bad_request
          [@http.#headers (http.headers (list))
           @http.#body (..url_body "")]]))))

(def .public test
  Test
  (<| (_.covering /._)
      (do [! random.monad]
        [address (random.upper_cased 10)
         uri (random.lower_cased 10)

         user (random.lower_cased 10)
         password (random.lower_cased 10)

         content (of ! each (of utf8.codec encoded)
                     (random.lower_cased 10))]
        (all _.and
             (_.coverage [/.repository /.user_agent /.Address]
               (let [repo (/.repository (..good_http user password)
                                        {.#Some [//identity.#user user
                                                 //identity.#password password]}
                                        address)]
                 (and (|> (of repo download uri)
                          io.run!
                          (try#each (of utf8.codec decoded))
                          try#conjoint
                          (try#each (text#= (format address uri)))
                          (try.else false))
                      (|> (of repo upload uri content)
                          io.run!
                          (try#each (function.constant true))
                          (try.else false)))))
             (_.coverage [/.upload_failure]
               (let [repo (/.repository (..good_http user password)
                                        {.#None}
                                        address)]
                 (when (io.run! (of repo upload uri content))
                   {try.#Failure error}
                   (exception.match? /.upload_failure error)
                   
                   {try.#Success _}
                   false)))
             (_.coverage [/.download_failure]
               (let [repo (/.repository ..bad_http
                                        {.#None}
                                        address)]
                 (when (io.run! (of repo download uri))
                   {try.#Failure error}
                   (exception.match? /.download_failure error)
                   
                   {try.#Success _}
                   false)))
             ))))