(.module:
  [lux (#- Module type)
   [abstract
    [monad (#+ do)]]
   [control
    ["<>" parser
     ["<c>" code (#+ Parser)]]]
   [data
    ["." text]
    [collection
     ["." dictionary (#+ Dictionary)]]]
   [tool
    [compiler
     [meta
      [archive
       [descriptor (#+ Module)]]]]]
   [world
    [net (#+ URL)]]]
  [//
   ["/" project]
   ["//." artifact (#+ Artifact)]
   ["//." dependency]])

(def: (as-input input)
  (-> (Maybe Code) (List Code))
  (case input
    (#.Some input)
    (list input)
    
    #.None
    (list)))

(def: (singular input tag parser)
  (All [a] (-> (Dictionary Text Code) Text (Parser a) (Parser a)))
  (<c>.local (..as-input (dictionary.get tag input))
             parser))

(def: (plural input tag parser)
  (All [a] (-> (Dictionary Text Code) Text (Parser a) (Parser (List a))))
  (<c>.local (..as-input (dictionary.get tag input))
             (<c>.tuple (<>.some parser))))

(def: group
  (Parser //artifact.Group)
  <c>.text)

(def: name
  (Parser //artifact.Name)
  <c>.text)

(def: version
  (Parser //artifact.Version)
  <c>.text)

(def: artifact'
  (Parser //artifact.Artifact)
  ($_ <>.and ..group ..name ..version))

(def: artifact
  (Parser //artifact.Artifact)
  (<c>.tuple ..artifact'))

(def: url
  (Parser URL)
  <c>.text)

(def: scm
  (Parser /.SCM)
  ..url)

(def: description
  (Parser Text)
  <c>.text)

(def: license
  (Parser /.License)
  (do {@ <>.monad}
    [input (:: @ map
               (dictionary.from-list text.hash)
               (<c>.record (<>.some (<>.and <c>.local-tag
                                            <c>.any))))]
    (<c>.tuple ($_ <>.and
                   (..singular input "name" ..name)
                   (..singular input "url" ..url)
                   (<>.default #/.Repo
                               (..singular input "type"
                                           (<>.or (<c>.this! (' #repo))
                                                  (<c>.this! (' #manual)))))))))

(def: organization
  (Parser /.Organization)
  (do {@ <>.monad}
    [input (:: @ map
               (dictionary.from-list text.hash)
               (<c>.record (<>.some (<>.and <c>.local-tag
                                            <c>.any))))]
    ($_ <>.and
        (..singular input "name" ..name)
        (..singular input "url" ..url))))

(def: developer
  (Parser /.Developer)
  (do {@ <>.monad}
    [input (:: @ map
               (dictionary.from-list text.hash)
               (<c>.record (<>.some (<>.and <c>.local-tag
                                            <c>.any))))]
    ($_ <>.and
        (..singular input "name" ..name)
        (..singular input "url" ..url)
        (<>.maybe (..singular input "organization" ..organization))
        )))

(def: contributor
  (Parser /.Contributor)
  ..developer)

(def: no-info
  /.Info
  {#/.url #.None
   #/.scm #.None
   #/.description #.None
   #/.licenses (list)
   #/.organization #.None
   #/.developers (list)
   #/.contributors (list)})

(def: info
  (Parser /.Info)
  (do {@ <>.monad}
    [input (:: @ map
               (dictionary.from-list text.hash)
               (<c>.record (<>.some (<>.and <c>.local-tag
                                            <c>.any))))]
    ($_ <>.and
        (<>.maybe (..singular input "url" ..url))
        (<>.maybe (..singular input "scm" ..scm))
        (<>.maybe (..singular input "description" ..description))
        (<>.default (list) (..plural input "licenses" ..license))
        (<>.maybe (..singular input "organization" ..organization))
        (<>.default (list) (..plural input "developers" ..developer))
        (<>.default (list) (..plural input "contributors" ..contributor))
        )))

(def: repository
  (Parser //dependency.Repository)
  ..url)

(def: type
  (Parser //dependency.Type)
  <c>.text)

(def: dependency
  (Parser //dependency.Dependency)
  (<c>.tuple
   ($_ <>.and
       ..artifact'
       (<>.default //dependency.lux-library ..type)
       )))

(def: source
  (Parser /.Source)
  <c>.text)

(def: module
  (Parser Module)
  <c>.text)

(def: deploy-repository
  (Parser [Text //dependency.Repository])
  (<c>.tuple (<>.and <c>.text
                     ..repository)))

(def: #export project
  (Parser /.Project)
  (do {@ <>.monad}
    [input (:: @ map
               (dictionary.from-list text.hash)
               (<c>.record (<>.some (<>.and <c>.local-tag
                                            <c>.any))))]
    ($_ <>.and
        (..singular input "identity" ..artifact)
        (<>.default ..no-info
                    (..singular input "info" ..info))
        (<>.default (list)
                    (..plural input "repositories" ..repository))
        (<>.default (list)
                    (..plural input "dependencies" ..dependency))
        (<>.default (list "source")
                    (..plural input "sources" ..source))
        (<>.default "target"
                    (..singular input "target" <c>.text))
        (<>.maybe (..singular input "program" ..module))
        (<>.maybe (..singular input "test" ..module))
        (<| (:: @ map (dictionary.from-list text.hash))
            (<>.default (list))
            (..plural input "deploy-repositories" ..deploy-repository))
        )))