(.module:
  [library
   [lux {"-" [Name Type]}
    [abstract
     [monad {"+" [do]}]
     [equivalence {"+" [Equivalence]}]]
    [control
     [pipe {"+" [do> case>]}]
     ["[0]" try {"+" [Try]}]
     ["[0]" exception {"+" [exception:]}]
     ["<>" parser
      ["<[0]>" xml {"+" [Parser]}]
      ["<[0]>" text]]
     [concurrency
      ["[0]" async {"+" [Async]}]]]
    [data
     ["[0]" product]
     ["[0]" text
      ["%" format]
      [encoding
       ["[0]" utf8]]]
     [format
      ["[0]" xml {"+" [XML]}]]
     [collection
      ["[0]" list ("[1]\[0]" functor)]]]
    [math
     [number
      ["n" nat]]]
    ["[0]" time {"+" [Time]}
     ["[0]" instant {"+" [Instant]}]
     ["[0]" date {"+" [Date]}]
     ["[0]" year]
     ["[0]" month]]
    [world
     [net
      ["[0]" uri {"+" [URI]}]]]]]
  ["[0]" //
   ["/[1]" // "_"
    [repository {"+" [Repository]}]
    ["[1][0]" artifact {"+" [Group Name Version Artifact]}
     ["[1]/[0]" time]
     ["[1]/[0]" type {"+" [Type]}]
     ["[1]/[0]" versioning {"+" [Versioning]}]
     ["[1]/[0]" snapshot
      ["[1]/[0]" version]
      ["[1]/[0]" stamp]]]]])

(type: .public Metadata
  (Record
   [#artifact Artifact
    #versioning Versioning]))

(template [<definition> <tag>]
  [(def: <definition> xml.Tag ["" <tag>])]

  [<group> "groupId"]
  [<name> "artifactId"]
  [<version> "version"]
  [<metadata> "metadata"]
  )

(template [<name> <type> <tag> <pre>]
  [(def: <name>
     (-> <type> XML)
     (|>> <pre> #xml.Text list (#xml.Node <tag> xml.attributes)))]

  [group_format Group ..<group> (|>)]
  [name_format Name ..<name> (|>)]
  [version_format Version ..<version> (|>)]
  )

(def: .public (format (^slots [#artifact #versioning]))
  (-> Metadata XML)
  (let [(^slots [#///artifact.group #///artifact.name #///artifact.version]) artifact]
    (#xml.Node ..<metadata>
               xml.attributes
               (list (..group_format group)
                     (..name_format name)
                     (..version_format version)
                     (///artifact/versioning.format versioning)))))

(def: (text tag)
  (-> xml.Tag (Parser Text))
  (<| (<xml>.node tag)
      <xml>.text))

(def: .public parser
  (Parser Metadata)
  (<| (<xml>.node ..<metadata>)
      (do [! <>.monad]
        [group (<xml>.somewhere (..text ..<group>))
         name (<xml>.somewhere (..text ..<name>))
         version (<xml>.somewhere (..text ..<version>))
         versioning (with_expansions [<default_version> [#///artifact/snapshot/version.extension ///artifact/type.jvm_library
                                                         #///artifact/snapshot/version.value version
                                                         #///artifact/snapshot/version.updated ///artifact/time.epoch]]
                      (|> (<xml>.somewhere ///artifact/versioning.parser)
                          (\ ! each
                             (revised@ #///artifact/versioning.versions
                                       (: (-> (List ///artifact/snapshot/version.Version)
                                              (List ///artifact/snapshot/version.Version))
                                          (|>> (case> (^ (list))
                                                      (list <default_version>)

                                                      versions
                                                      versions)))))
                          (<>.else [#///artifact/versioning.snapshot #///artifact/snapshot.Local
                                    #///artifact/versioning.last_updated ///artifact/time.epoch
                                    #///artifact/versioning.versions (list <default_version>)])))]
        (in [#artifact [#///artifact.group group
                        #///artifact.name name
                        #///artifact.version version]
             #versioning versioning]))))

(def: .public equivalence
  (Equivalence Metadata)
  ($_ product.equivalence
      ///artifact.equivalence
      ///artifact/versioning.equivalence
      ))

(def: .public uri
  (-> Artifact URI)
  //.remote_artifact_uri)

(def: .public (read repository artifact)
  (-> (Repository Async) Artifact (Async (Try Metadata)))
  (do async.monad
    [project (\ repository download (..uri artifact))]
    (case project
      (#try.Success project)
      (in (|> project
              (do> try.monad
                   [(\ utf8.codec decoded)]
                   [(\ xml.codec decoded)]
                   [list (<xml>.result ..parser)])))
      
      (#try.Failure error)
      (in (#try.Success
           [#artifact artifact
            #versioning ///artifact/versioning.init])))))

(def: .public (write repository artifact metadata)
  (-> (Repository Async) Artifact Metadata (Async (Try Any)))
  (|> metadata
      ..format
      (\ xml.codec encoded)
      (\ utf8.codec encoded)
      (\ repository upload (..uri artifact))))