(.using
  [library
   [lux {"-" local}
    [abstract
     [equivalence {"+" Equivalence}]
     [order {"+" Order}]
     [hash {"+" Hash}]]
    [data
     ["[0]" product]
     ["[0]" text ("[1]#[0]" order)
      ["%" format {"+" Format}]]
     [collection
      ["[0]" list ("[1]#[0]" monoid)]]]
    [world
     ["[0]" file {"+" Path}]
     [net
      ["[0]" uri {"+" URI}]]]]])

(type: .public Group
  Text)

(type: .public Name
  Text)

(type: .public Version
  Text)

(type: .public Artifact
  (Record
   [#group Group
    #name Name
    #version Version]))

(def: .public hash
  (Hash Artifact)
  ($_ product.hash
      text.hash
      text.hash
      text.hash
      ))

(def: .public equivalence
  (Equivalence Artifact)
  (# ..hash &equivalence))

(implementation: .public order
  (Order Artifact)

  (def: &equivalence
    ..equivalence)

  (def: (< reference subject)
    (<| (or (text#< (value@ #group reference)
                    (value@ #group subject)))

        (and (text#= (value@ #group reference)
                     (value@ #group subject)))
        (or (text#< (value@ #name reference)
                    (value@ #name subject)))
        
        (and (text#= (value@ #name reference)
                     (value@ #name subject)))
        (text#< (value@ #version reference)
                (value@ #version subject)))))

(template [<separator> <definition>]
  [(def: <definition>
     Text
     <separator>)]

  ["." group_separator]
  ["-" version_separator]
  [":" identity_separator]
  )

(def: .public (identity artifact)
  (-> Artifact Text)
  (%.format (value@ #name artifact)
            ..version_separator
            (value@ #version artifact)))

(def: .public (format value)
  (Format Artifact)
  (%.format (value@ #group value)
            ..identity_separator
            (..identity value)))

(def: .public (directory separator group)
  (-> Text Group Text)
  (|> group
      (text.all_split_by ..group_separator)
      (text.interposed separator)))

(def: .public (uri version artifact)
  (-> Version Artifact URI)
  (let [/ uri.separator
        group (..directory / (value@ #group artifact))
        name (value@ #name artifact)
        ... version (value@ #version artifact)
        identity (..identity artifact)]
    (%.format group / name / version / identity)))

(def: .public (local artifact)
  (-> Artifact (List Text))
  (list#composite (|> artifact
                      (value@ #group)
                      (text.all_split_by ..group_separator))
                  (list (value@ #name artifact)
                        (value@ #version artifact))))