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

(type: #export Metadata
  {#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)))]

  [format_group Group ..<group> (|>)]
  [format_name Name ..<name> (|>)]
  [format_version Version ..<version> (|>)]
  )

(def: #export (format (^slots [#artifact #versioning]))
  (-> Metadata XML)
  (let [(^slots [#///artifact.group #///artifact.name #///artifact.version]) artifact]
    (#xml.Node ..<metadata>
               xml.attributes
               (list (..format_group group)
                     (..format_name name)
                     (..format_version version)
                     (///artifact/versioning.format versioning)))))

(def: (sub tag parser)
  (All [a] (-> xml.Tag (Parser a) (Parser a)))
  (do <>.monad
    [_ (<xml>.node tag)]
    (<xml>.children parser)))

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

(def: #export parser
  (Parser Metadata)
  (<| (..sub ..<metadata>)
      (do {! <>.monad}
        [group (<xml>.somewhere (..text ..<group>))
         name (<xml>.somewhere (..text ..<name>))
         version (<xml>.somewhere (..text ..<version>))
         versioning (\ ! map
                       (update@ #///artifact/versioning.versions
                                (: (-> (List ///artifact/snapshot/version.Version)
                                       (List ///artifact/snapshot/version.Version))
                                   (|>> (case> (^ (list))
                                               (list {#///artifact/snapshot/version.extension ///artifact/type.jvm_library
                                                      #///artifact/snapshot/version.value version
                                                      #///artifact/snapshot/version.updated ///artifact/time.epoch})

                                               versions
                                               versions))))
                       (<xml>.somewhere ///artifact/versioning.parser))]
        (wrap {#artifact {#///artifact.group group
                          #///artifact.name name
                          #///artifact.version version}
               #versioning versioning}))))

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

(def: #export (uri artifact)
  (-> Artifact URI)
  (let [/ uri.separator
        group (|> artifact
                  (get@ #///artifact.group)
                  (///artifact.directory /))
        name (get@ #///artifact.name artifact)
        version (get@ #///artifact.version artifact)]
    (%.format group / name / version / //.remote_file)))

(def: #export (read repository artifact)
  (-> (Repository Promise) Artifact (Promise (Try Metadata)))
  (do promise.monad
    [project (\ repository download (..uri artifact))]
    (case project
      (#try.Success project)
      (wrap (|> project
                (do> try.monad
                     [(\ utf8.codec decode)]
                     [(\ xml.codec decode)]
                     [list (<xml>.run ..parser)])))
      
      (#try.Failure error)
      (wrap (#try.Success
             {#artifact artifact
              #versioning ///artifact/versioning.init})))))

(def: #export (write repository artifact metadata)
  (-> (Repository Promise) Artifact Metadata (Promise (Try Any)))
  (|> metadata
      ..format
      (\ xml.codec encode)
      (\ utf8.codec encode)
      (\ repository upload (..uri artifact))))