(.require
 [library
  [lux (.except)
   [abstract
    [equivalence (.only Equivalence)]
    [monad (.only do)]]
   [control
    ["<>" parser]]
   [data
    ["[0]" sum]
    ["[0]" product]
    ["[0]" text]]
   [program
    ["cli" \\parser (.only Parser)]]]]
 [//
  [repository
   [identity (.only Identity)]]
  ["/" profile (.only Name)]])

(type .public Compilation
  (Variant
   {#Build}
   {#Test}))

(def any_equivalence
  (Equivalence Any)
  (implementation
   (def (= reference subject)
     true)))

(def compilation_equivalence
  (Equivalence Compilation)
  (sum.equivalence ..any_equivalence
                   ..any_equivalence))

(def compilation
  (Parser Compilation)
  (<>.or (cli.this "build")
         (cli.this "test")))

(type .public Command
  (Variant
   {#Version}
   {#Clean}
   {#POM}
   {#Dependencies}
   {#Install}
   {#Deploy Text Identity}
   {#Compilation Compilation}
   {#Auto Compilation}))

(def .public equivalence
  (Equivalence Command)
  (all sum.equivalence
       ... #Version
       ..any_equivalence
       ... #Clean
       ..any_equivalence
       ... #POM
       ..any_equivalence
       ... #Dependencies
       ..any_equivalence
       ... #Install
       ..any_equivalence
       ... #Deploy
       (all product.equivalence
            text.equivalence
            text.equivalence
            text.equivalence)
       ... #Compilation
       ..compilation_equivalence
       ... #Auto
       ..compilation_equivalence))

(def command'
  (Parser Command)
  (all <>.or
       (cli.this "version")
       (cli.this "clean")
       (cli.this "pom")
       (cli.this "deps")
       (cli.this "install")
       (<>.after (cli.this "deploy")
                 (<>.and cli.any
                         (<>.and cli.any
                                 cli.any)))
       ..compilation
       (<>.after (cli.this "auto")
                 ..compilation)
       ))

(def .public command
  (Parser [(List Name) Command])
  (<>.rec
   (function (_ command)
     (all <>.either
          (<>.after (cli.this "with")
                    (do <>.monad
                      [head cli.any
                       [tail command] command]
                      (in [{.#Item head tail} command])))
          (at <>.monad each (|>> [(list)])
              ..command')
          ))))