(.using
 [library
  [lux (.full)
   [data
    ["[0]" text ("[1]#[0]" equivalence)]
    [collection
     ["[0]" dictionary (.only Dictionary)]
     ["[0]" list ("[1]#[0]" monad)]
     ["[0]" set (.only Set)]]]
   [macro
    ["[0]" code]
    ["[0]" template]]
   [tool
    [compiler
     [meta
      [cli
       [compiler (.only Compiler)]]]]]]]
 ["[0]" // "_"
  ["/" profile]
  ["[1][0]" runtime (.only Runtime)]
  ["[1][0]" project (.only Project)]
  ["[1][0]" dependency (.only Dependency)]
  ["[1][0]" artifact (.only Artifact)
   ["[1]/[0]" type]]])

(type: .public (Format a)
  (-> a Code))

(def: (license [name url type])
  (Format /.License)
  (`' [#name (~ (code.text name))
       #url (~ (code.text url))
       #type (~ (case type
                  {/.#Repo}
                  (' "repo")

                  {/.#Manual}
                  (' "manual")))]))

(def: (organization [name url])
  (Format /.Organization)
  (`' [#name (~ (code.text name))
       #url (~ (code.text url))]))

(def: (developer [name url organization])
  (Format /.Developer)
  (case organization
    {.#None}
    (`' [#name (~ (code.text name))
         #url (~ (code.text url))])

    {.#Some value}
    (`' [#name (~ (code.text name))
         #url (~ (code.text url))
         #organization (~ (..organization value))])))

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

(type: Aggregate
  (Dictionary Text Code))

(def: aggregate
  (Format Aggregate)
  (|>> dictionary.entries
       (list#each (function (_ [key value])
                    (list (code.text key) value)))
       list#conjoint
       code.tuple))

(def: empty
  Aggregate
  (dictionary.empty text.hash))

(def: (on_maybe field value format aggregate)
  (All (_ a)
    (-> Text (Maybe a) (Format a) Aggregate Aggregate))
  (case value
    {.#None}
    aggregate

    {.#Some value}
    (dictionary.has field (format value) aggregate)))

(def: (on_list field value format aggregate)
  (All (_ a)
    (-> Text (List a) (Format a) Aggregate Aggregate))
  (case value
    {.#End}
    aggregate

    value
    (dictionary.has field (` [(~+ (list#each format value))]) aggregate)))

(def: (on_set field value format aggregate)
  (All (_ a)
    (-> Text (Set a) (Format a) Aggregate Aggregate))
  (..on_list field (set.list value) format aggregate))

(def: (on_dictionary field value key_format value_format aggregate)
  (All (_ k v)
    (-> Text (Dictionary k v) (Format k) (Format v) Aggregate Aggregate))
  (if (dictionary.empty? value)
    aggregate
    (dictionary.has field
                    (|> value
                        dictionary.entries
                        (list#each (function (_ [key value])
                                     (list (key_format key) (value_format value))))
                        list#conjoint
                        code.tuple)
                    aggregate)))

(def: (info value)
  (Format /.Info)
  (|> ..empty
      (..on_maybe "name" (the /.#name value) code.text)
      (..on_maybe "url" (the /.#url value) code.text)
      (..on_maybe "scm" (the /.#scm value) code.text)
      (..on_maybe "description" (the /.#description value) code.text)
      (..on_list "licenses" (the /.#licenses value) ..license)
      (..on_maybe "organization" (the /.#organization value) ..organization)
      (..on_list "developers" (the /.#developers value) ..developer)
      (..on_list "contributors" (the /.#contributors value) ..contributor)
      ..aggregate))

(def: (artifact' [group name version])
  (-> Artifact (List Code))
  (list (code.text group)
        (code.text name)
        (code.text version)))

(def: (artifact value)
  (Format Artifact)
  (` [(~+ (..artifact' value))]))

(def: (dependency [artifact type])
  (Format Dependency)
  (if (text#= //artifact/type.lux_library type)
    (` [(~+ (..artifact' artifact))])
    (` [(~+ (..artifact' artifact))
        (~ (code.text type))])))

(def: (runtime [environment program parameters])
  (Format Runtime)
  (` [(~+ (list#each (function (_ [var value])
                       (` [(~ (code.text var))
                           (~ (code.text value))]))
                     (dictionary.entries environment)))
      (~ (code.text program))
      (~+ (list#each code.text parameters))]))

(def: (compiler [definition parameters])
  (Format Compiler)
  (` [(~ (code.symbol definition))
      (~+ (list#each code.text parameters))]))

(def: .public lux_compiler_label
  "lux")

(def: (profile value)
  (Format /.Profile)
  (`` (|> ..empty
          (..on_list "parents" (the /.#parents value) code.text)
          (..on_maybe "identity" (the /.#identity value) ..artifact)
          (..on_maybe "info" (the /.#info value) ..info)
          (..on_set "repositories" (the /.#repositories value) code.text)
          (..on_set "dependencies" (the /.#dependencies value) ..dependency)
          (dictionary.has ..lux_compiler_label (..dependency (the /.#lux value)))
          (..on_list "compilers" (the /.#compilers value) ..compiler)
          (..on_set "sources" (the /.#sources value) code.text)
          (dictionary.has "target" (code.text (the /.#target value)))
          (..on_maybe "program" (the /.#program value) code.text)
          (..on_maybe "test" (the /.#test value) code.text)
          (..on_dictionary "deploy_repositories" (the /.#deploy_repositories value) code.text code.text)
          (~~ (template [<tag>]
                [(dictionary.has (template.text [<tag>]) (..runtime (the <tag> value)))]

                [/.#java]
                [/.#js]
                [/.#python]
                [/.#lua]
                [/.#ruby]))
          ..aggregate)))

(def: .public project
  (Format Project)
  (|>> dictionary.entries
       (list#each (function (_ [key value])
                    (list (code.text key) (..profile value))))
       list#conjoint
       code.tuple))