(.module:
  [lux #*
   [abstract
    [monad (#+ do)]]
   [control
    [pipe (#+ case>)]
    ["." try (#+ Try)]
    ["." exception]
    ["<>" parser
     ["<xml>" xml (#+ Parser)]]]
   [data
    ["." name]
    ["." maybe ("#\." functor)]
    [format
     ["_" xml (#+ Tag XML)]]
    [collection
     ["." list ("#\." monoid functor fold)]
     ["." set]
     ["." dictionary]]]]
  ["." // #_
   ["/" profile]
   ["#." repository (#+ Address)]
   ["#." dependency (#+ Dependency)]
   ["#." artifact (#+ Artifact)
    ["#/." type]]])

## https://maven.apache.org/pom.html

(def: project-tag "project")
(def: dependencies-tag "dependencies")
(def: group-tag "groupId")
(def: artifact-tag "artifactId")
(def: version-tag "version")

(def: #export file
  "pom.xml")

(def: version
  XML
  (#_.Node ["" "modelVersion"] _.attributes
           (list (#_.Text "4.0.0"))))

(def: (property tag value)
  (-> Text Text XML)
  (#_.Node ["" tag]
           _.attributes
           (list (#_.Text value))))

(def: (artifact value)
  (-> Artifact (List XML))
  (list (..property ..group-tag (get@ #//artifact.group value))
        (..property ..artifact-tag (get@ #//artifact.name value))
        (..property ..version-tag (get@ #//artifact.version value))))

(def: distribution
  (-> /.Distribution XML)
  (|>> (case> #/.Repo "repo"
              #/.Manual "manual")
       (..property "distribution")))

(def: (license [name url distribution])
  (-> /.License XML)
  (|> (list (..property "name" name)
            (..property "url" url)
            (..distribution distribution))
      (#_.Node ["" "license"] _.attributes)))

(def: repository
  (-> Address XML)
  (|>> (..property "url")
       list
       (#_.Node ["" "repository"] _.attributes)))

(def: (dependency value)
  (-> Dependency XML)
  (#_.Node ["" "dependency"]
           _.attributes
           (list\compose (..artifact (get@ #//dependency.artifact value))
                         (list (..property "type" (get@ #//dependency.type value))))))

(def: (group tag)
  (-> Text (-> (List XML) XML))
  (|>> (#_.Node ["" tag] _.attributes)))

(comment
  (def: scm
    (-> /.SCM XML)
    (|>> (..property "url")
         list
         (#_.Node ["" "scm"] _.attributes)))

  (def: (organization [name url])
    (-> /.Organization XML)
    (|> (list (..property "name" name)
              (..property "url" url))
        (#_.Node ["" "organization"] _.attributes)))

  (def: (developer-organization [name url])
    (-> /.Organization (List XML))
    (list (..property "organization" name)
          (..property "organizationUrl" url)))

  (def: (developer' [name email organization])
    (-> /.Developer (List XML))
    (list& (..property "name" name)
           (..property "email" email)
           (|> organization (maybe\map ..developer-organization) (maybe.default (list)))))

  (template [<name> <type> <tag>]
    [(def: <name>
       (-> <type> XML)
       (|>> ..developer' (#_.Node ["" <tag>] _.attributes)))]

    [developer /.Developer "developer"]
    [contributor /.Contributor "contributor"]
    )

  (def: (info value)
    (-> /.Info (List XML))
    ($_ list\compose
        (|> value (get@ #/.url) (maybe\map (..property "url")) maybe.to-list)
        (|> value (get@ #/.description) (maybe\map (..property "description")) maybe.to-list)
        (|> value (get@ #/.licenses) (list\map ..license) (..group "licenses") list)
        (|> value (get@ #/.scm) (maybe\map ..scm) maybe.to-list)
        (|> value (get@ #/.organization) (maybe\map ..organization) maybe.to-list)
        (|> value (get@ #/.developers) (list\map ..developer) (..group "developers") list)
        (|> value (get@ #/.contributors) (list\map ..contributor) (..group "contributors") list)
        ))
  )

(def: #export (write value)
  (-> /.Profile (Try XML))
  (case (get@ #/.identity value)
    (#.Some identity)
    (#try.Success
     (#_.Node ["" ..project-tag] _.attributes
              ($_ list\compose
                  (list ..version)
                  (..artifact identity)
                  (|> value (get@ #/.repositories) set.to-list (list\map ..repository) (..group "repositories") list)
                  (|> value (get@ #/.dependencies) set.to-list (list\map ..dependency) (..group ..dependencies-tag) list)
                  )))

    _
    (exception.throw /.no-identity [])))

(def: parse-property
  (Parser [Tag Text])
  (<>.and <xml>.tag
          (<xml>.children <xml>.text)))

(def: parse-dependency
  (Parser Dependency)
  (do {! <>.monad}
    [properties (\ ! map (dictionary.from-list name.hash)
                   (<xml>.children (<>.some ..parse-property)))]
    (<| <>.lift
        try.from-maybe
        (do maybe.monad
          [group (dictionary.get ["" ..group-tag] properties)
           artifact (dictionary.get ["" ..artifact-tag] properties)
           version (dictionary.get ["" ..version-tag] properties)]
          (wrap {#//dependency.artifact {#//artifact.group group
                                         #//artifact.name artifact
                                         #//artifact.version version}
                 #//dependency.type (|> properties
                                        (dictionary.get ["" "type"])
                                        (maybe.default //artifact/type.lux-library))})))))

(def: parse-dependencies
  (Parser (List Dependency))
  (do {! <>.monad}
    [_ (<xml>.node ["" ..dependencies-tag])]
    (<xml>.children (<>.some ..parse-dependency))))

(def: #export parser
  (Parser /.Profile)
  (do {! <>.monad}
    [_ (<xml>.node ["" ..project-tag])]
    (<xml>.children
     (do !
       [dependencies (<xml>.somewhere ..parse-dependencies)
        _ (<>.some <xml>.ignore)]
       (wrap (|> (\ /.monoid identity)
                 (update@ #/.dependencies (function (_ empty)
                                            (list\fold set.add empty dependencies)))))))))