(.module:
  [lux (#- Name)
   [abstract
    [monad (#+ do)]]
   [control
    [pipe (#+ do>)]
    ["." try (#+ Try)]
    ["." io (#+ IO)]
    [parser
     ["." cli (#+ program:)]
     ["<c>" code]]
    [security
     ["!" capability]]
    [concurrency
     ["." promise (#+ Promise)]]]
   [data
    [binary (#+ Binary)]
    ["." text
     ["%" format (#+ format)]
     ["." encoding]]
    [format
     ["." xml]]
    [collection
     ["." set]]]
   [tool
    [compiler
     [language
      [lux
       ["." syntax]]]]]
   [world
    ["." file (#+ Path)]]]
  ["." / #_
   [action (#+ Action)]
   ["#" profile]
   ["#." project (#+ Project)]
   ["#." parser]
   ["#." pom]
   ["#." cli]
   ["#." local]
   ["#." dependency]
   [command
    ["#." build]
    ["#." test]
    ["#." auto]
    ["#." deploy]]])

(def: (read-file! path)
  (-> Path (IO (Try Binary)))
  (do (try.with io.monad)
    [project-file (!.use (:: file.system file) [path])]
    (!.use (:: project-file content) [])))

(def: (read-code source-code)
  (-> Text (Try Code))
  (let [parse (syntax.parse ""
                            syntax.no-aliases
                            (text.size source-code))
        start (: Source
                 [["" 0 0] 0 source-code])]
    (case (parse start)
      (#.Left [end error])
      (#try.Failure error)
      
      (#.Right [end lux-code])
      (#try.Success lux-code))))

(def: (write-pom!' path profile)
  (-> Path /.Profile (IO (Try Any)))
  (do (try.with io.monad)
    [file (!.use (:: file.system file) [path])
     pom (:: io.monad wrap (/pom.project profile))]
    (|> pom
        (:: xml.codec encode)
        encoding.to-utf8
        (!.use (:: file over-write)))))

(def: (write-pom! profile)
  (-> /.Profile (IO Any))
  (do io.monad
    [outcome (write-pom!' /pom.file profile)]
    (case outcome
      (#try.Success value)
      (wrap (log! "Successfully wrote POM file!"))
      
      (#try.Failure error)
      (wrap (log! (format "Could not write POM file:" text.new-line
                          error))))))

(def: (install! profile)
  (-> /.Profile (Promise Any))
  (do promise.monad
    [outcome (/local.install (file.async file.system) profile)]
    (wrap (case outcome
            (#try.Success _)
            (log! "Successfully installed locally!")
            
            (#try.Failure error)
            (log! (format "Could not install locally:" text.new-line
                          error))))))

(def: (fetch-dependencies! profile)
  (-> /.Profile (Promise Any))
  (do promise.monad
    [outcome (do (try.with promise.monad)
               [cache (/local.all-cached (file.async file.system)
                                         (set.to-list (get@ #/.dependencies profile))
                                         /dependency.empty)
                resolution (promise.future
                            (/dependency.resolve-all (set.to-list (get@ #/.repositories profile))
                                                     (set.to-list (get@ #/.dependencies profile))
                                                     cache))]
               (/local.cache-all (file.async file.system)
                                 resolution))]
    (wrap (case outcome
            (#try.Success _)
            (log! "Successfully resolved dependencies!")
            
            (#try.Failure error)
            (log! (format "Could not resolve dependencies:" text.new-line
                          error))))))

(def: project
  (-> Binary (Try Project))
  (|>> (do> try.monad
            [encoding.from-utf8]
            [..read-code]
            [(list) (<c>.run /parser.project)])))

(program: [{[profile operation] /cli.command}]
  (do {@ io.monad}
    [data (..read-file! /.file)]
    (case (do try.monad
            [data data
             project (..project data)]
            (/project.profile project profile))
      (#try.Success profile)
      (case operation
        #/cli.POM
        (..write-pom! profile)
        
        #/cli.Dependencies
        (exec (..fetch-dependencies! profile)
          (wrap []))

        #/cli.Install
        (exec (..install! profile)
          (wrap []))

        (#/cli.Deploy repository user password)
        (exec (/deploy.do! repository user password profile)
          (wrap []))

        (#/cli.Compilation compilation)
        (case compilation
          #/cli.Build (exec (/build.do! profile)
                        (wrap []))
          #/cli.Test (exec (/test.do! profile)
                       (wrap [])))

        (#/cli.Auto auto)
        (exec (case auto
                #/cli.Build (/auto.do! /build.do! profile)
                #/cli.Test (/auto.do! /test.do! profile))
          (wrap [])))
      
      (#try.Failure error)
      (wrap (log! error)))))