main.cljc

(ns figwheel.main
  #?(:clj
       (:require
        [cljs.analyzer :as ana]
        [cljs.analyzer.api :as ana-api]
        [cljs.build.api :as bapi]
        [cljs.cli :as cli]
        [cljs.env]
        [cljs.main :as cm]
        [cljs.repl]
        [cljs.repl.figwheel]
        [cljs.util]
        [clojure.java.io :as io]
        [clojure.pprint :refer [pprint]]
        [clojure.string :as string]
        [clojure.edn :as edn]
        [clojure.tools.reader.edn :as redn]
        [clojure.tools.reader.reader-types :as rtypes]
        [figwheel.core :as fw-core]
        [figwheel.main.ansi-party :as ansip]
        [figwheel.main.logging :as log]
        [figwheel.main.util :as fw-util]
        [figwheel.main.watching :as fww]
        [figwheel.main.helper :as helper]
        [figwheel.main.npm :as npm]
        [figwheel.main.async-result :as async-result]
        [figwheel.main.testing :as testing]
        [figwheel.repl :as fw-repl]
        [figwheel.tools.exceptions :as fig-ex]))
  #?(:clj
     (:import
      [java.io StringReader]
      java.net.InetAddress
      java.net.URI
      java.net.URLEncoder
      java.nio.file.Paths))
  #?(:cljs
     (:require-macros [figwheel.main])))

#?(:clj
   (do

(def ^:dynamic *base-config*)
(def ^:dynamic *config*)

(def default-target-dir "target")

(defonce process-unique (subs (str (java.util.UUID/randomUUID)) 0 6))

(defn- time-elapsed [started-at]
  (let [elapsed-us (- (System/currentTimeMillis) started-at)]
    (with-precision 2
      (str (/ (double elapsed-us) 1000) " seconds"))))

(defn- wrap-with-build-logging [build-fn]
  (fn [id? & args]
    (let [started-at (System/currentTimeMillis)
          {:keys [output-to output-dir]} (second args)]
      ;; print start message
      (log/info (str "Compiling build"
                     (when id? (str " " id?))
                     " to \""
                     (or output-to output-dir)
                     "\""))
      (try
        (let [warnings (volatile! [])
              out *out*
              warning-fn (fn [warning-type env extra]
                            (when (get cljs.analyzer/*cljs-warnings* warning-type)
                              (let [warn {:warning-type warning-type
                                          :env env
                                          :extra extra
                                          :path ana/*cljs-file*}]
                                (binding [*out* out]
                                  (if (<= (count @warnings) 2)
                                    (log/cljs-syntax-warning warn)
                                    (binding [log/*syntax-error-style* :concise]
                                      (log/cljs-syntax-warning warn))))
                                (vswap! warnings conj warn))))]
          (binding [cljs.analyzer/*cljs-warning-handlers*
                    (conj (remove #{cljs.analyzer/default-warning-handler}
                                  cljs.analyzer/*cljs-warning-handlers*)
                          warning-fn)]
            (apply build-fn args)))
        (log/succeed (str "Successfully compiled build"
                       (when id? (str " " id?))
                       " to \""
                       (or output-to output-dir)
                       "\" in " (time-elapsed started-at) "."))
        (catch Throwable e
          (log/failure (str
                        "Failed to compile build" (when id? (str " " id?))
                        " in " (time-elapsed started-at) "."))
          (log/syntax-exception e)
          (throw e))))))

(declare resolve-fn-var)

(defn run-hooks [hooks & args]
  (when (not-empty hooks)
    (doseq [h hooks]
      (apply h args))))

(defn- wrap-with-build-hooks [build-fn]
  (fn [& args]
    (run-hooks (::pre-build-hooks *config*) *config*)
    (apply build-fn args)
    (run-hooks (::post-build-hooks *config*) *config*)))

(def build-cljs
  (-> bapi/build wrap-with-build-logging wrap-with-build-hooks))

(def fig-core-build
  (-> figwheel.core/build wrap-with-build-logging wrap-with-build-hooks))

;; TODO the word config is soo abused in this namespace that it's hard to
;; know what and argument is supposed to be
(defn config->reload-config [config]
  (select-keys config [:reload-clj-files :wait-time-ms :hawk-options]))

(defn watch-build [id paths inputs opts cenv & [reload-config]]
  (when-let [inputs (not-empty (if (coll? inputs) inputs [inputs]))]
    (let [build-inputs (if (coll? inputs) (apply bapi/inputs inputs) inputs)
          ;; the build-fn needs to be passed in before here?
          build-fn (if (some #{'figwheel.core} (:preloads opts))
                     #(fig-core-build id build-inputs opts cenv %)
                     (fn [files] (build-cljs id build-inputs opts cenv)))]
      (log/info "Watching paths:" (pr-str paths) "to compile build -" id)
      (log/debug "Build Inputs:" (pr-str inputs))
      (binding [fww/*hawk-options* (:hawk-options reload-config nil)]
        (fww/add-watch!
         [::autobuild id]
         (merge
          {::watch-info (merge
                         (:extra-info reload-config)
                         {:id id
                          :paths paths
                          :inputs inputs
                          :options opts
                          :compiler-env cenv
                          :reload-config reload-config})}
          {:paths paths
           :filter (fww/suffix-filter #{"cljc" "cljs" "js" "clj"})
           :handler (fww/throttle
                     (:wait-time-ms reload-config 50)
                     (bound-fn [evts]
                       (binding [cljs.env/*compiler* cenv]
                         (let [files (mapv (comp #(.getCanonicalPath %) :file) evts)]
                           (try
                             (when-let [clj-files
                                        (->> evts
                                             (filter
                                              (partial
                                               (fww/suffix-filter
                                                (set
                                                 (cond
                                                   (coll? (:reload-clj-files reload-config))
                                                   (mapv name (:reload-clj-files reload-config))
                                                   (false? (:reload-clj-files reload-config)) []
                                                   :else ["clj" "cljc"]))) nil))
                                             (mapv (comp #(.getCanonicalPath %) :file))
                                             not-empty)]
                               (log/debug "Reloading clj files: " (pr-str (map str clj-files)))
                               (try
                                 (figwheel.core/reload-clj-files clj-files)
                                 (catch Throwable t
                                   (if (-> t ex-data :figwheel.core/internal)
                                     (log/error (.getMessage t) t)
                                     (do
                                       (log/syntax-exception t)
                                       (figwheel.core/notify-on-exception cenv t {})))
                                   ;; skip cljs reloading in this case
                                   (throw t))))
                             (log/debug "Detected changed cljs files: " (pr-str (map str files)))
                             (build-fn files)
                             (catch Throwable t
                               (log/error t)
                               (log/debug (with-out-str (clojure.pprint/pprint (Throwable->map t))))
                               false))))))}))))))


(declare read-edn-file)

(defn get-edn-file-key
  ([edn-file key] (get-edn-file-key edn-file key nil))
  ([edn-file key default]
   (try (get (read-string (slurp edn-file)) key default)
        (catch Throwable t default))))

(def validate-config!*
  (when (try
          (require 'clojure.spec.alpha)
          (require 'expound.alpha)
          (require 'expound.ansi)
          (require 'figwheel.main.schema.config)
          (require 'figwheel.main.schema.cljs-options)
          (require 'figwheel.main.schema.cli)
          true
          (catch Throwable t false))
    (resolve 'figwheel.main.schema.core/validate-config!)))

(defn validate-config! [spec edn fail-msg & [succ-msg]]
  (when (and validate-config!*
             (not
              (false?
               (:validate-config
                edn
                (get-edn-file-key "figwheel-main.edn" :validate-config)))))
    (expound.ansi/with-color-when (:ansi-color-output edn true)
      (validate-config!* spec edn fail-msg))
    (when succ-msg
      (log/succeed succ-msg))))

(def validate-cli!*
  (when validate-config!*
    (resolve 'figwheel.main.schema.cli/validate-cli!)))

(defn validate-cli! [cli-args & [succ-msg]]
  (when (and validate-cli!*
             (get-edn-file-key "figwheel-main.edn" :validate-cli true))
    (expound.ansi/with-color-when
      (get-edn-file-key "figwheel-main.edn" :ansi-color-output true)
      (validate-cli!* cli-args "Error in command line args"))
    (when succ-msg
      (log/succeed succ-msg))))

;; ----------------------------------------------------------------------------
;; Additional cli options
;; ----------------------------------------------------------------------------

;; Help


(def help-template
  "Usage: clojure -m figwheel.main [init-opt*] [main-opt] [arg*]

Common usage:
  clj -m figwheel.main -b dev -r
Which is equivalient to:
  clj -m figwheel.main -co dev.cljs.edn -c example.core -r

In the above example, dev.cljs.edn is a file in the current directory
that holds a build configuration which is a Map of ClojureScript
compile options. In the above command example.core is ClojureScript
namespace on your classpath that you want to compile.

A minimal dev.cljs.edn will look similar to:
{:main example.core}

The above command will start a watch process that will compile your
source files when one of them changes, it will also facilitate
communication between this watch process and your JavaScript
environment (normally a browser window) so that it can hot reload
changed code into the environment. After the initial compile, it
will then launch a browser to host your compiled ClojureScript code,
and finally a CLJS REPL will launch.

Configuration:

In the above example, besides looking for a dev.cljs.edn file,
figwheel.main will also look for a figwheel-main.edn file in the
current directory as well.

A list of all the config options can be found here:
https://github.com/bhauman/figwheel-main/blob/master/doc/figwheel-main-options.md

A list of ClojureScript compile options can be found here:
https://clojurescript.org/reference/compiler-options

You can add build specific figwheel.main configuration in the
*.cljs.edn file by adding metadata to the build config file like
so:

^{:watch-dirs [\"dev\" \"cljs-src\"]}
{:main example.core}

Command Line Options:

With no options or args, figwheel.main runs a ClojureScript REPL

%s
For --main and --repl:

  - Enters the cljs.user namespace
  - Binds *command-line-args* to a seq of strings containing command line
    args that appear after any main option
  - Runs all init options in order
  - Calls a -main function or runs a repl or script if requested

The init options may be repeated and mixed freely, but must appear before
any main option.

In the case of --compile and --build you may supply --repl or --serve
options afterwards.

Paths may be absolute or relative in the filesystem or relative to
classpath. Classpath-relative paths have prefix of @ or @/")

(defn adjust-option-docs [commands]
  (-> commands
      (update-in [:groups :cljs.cli/main&compile :pseudos]
                 dissoc ["-re" "--repl-env"])
      (assoc-in [:init ["-d" "--output-dir"] :doc]
                "Set the output directory to use")
      (update-in [:init ["-w" "--watch"] :doc] str
                ". This option can be supplied multiple times.")))

(defn help-str [repl-env]
  (format
   help-template
   (#'cljs.cli/options-str
    (adjust-option-docs
     (#'cljs.cli/merged-commands repl-env)))))

(defn help-opt
  [repl-env _ _]
  (println (help-str repl-env)))

;; safer option reading from files which prints out syntax errors

(defn read-edn-file [f]
  (try (redn/read
        (rtypes/source-logging-push-back-reader (io/reader f) 1 f))
       (catch Throwable t
         (log/syntax-exception t)
         (throw
          (ex-info (str "Couldn't read the file:" f)
                   {::error true} t)))))

(defn read-edn-string [s & [fail-msg]]
  (try
    (redn/read
     (rtypes/source-logging-push-back-reader (io/reader (.getBytes s)) 1))
    (catch Throwable t
      (let [except-data (fig-ex/add-excerpt (fig-ex/parse-exception t) s)]
        (log/info (ansip/format-str (log/format-ex except-data)))
        (throw (ex-info (str (or fail-msg "Failed to read EDN string: ")
                             (.getMessage t))
                        {::error true}
                        t))))))

(defn read-edn-opts [str]
  (letfn [(read-rsrc [rsrc-str orig-str]
            (if-let [rsrc (io/resource rsrc-str)]
              (read-edn-string (slurp rsrc))
              (cljs.cli/missing-resource orig-str)))]
    (cond
     (string/starts-with? str "@/") (read-rsrc (subs str 2) str)
     (string/starts-with? str "@") (read-rsrc (subs str 1) str)
     :else
     (let [f (io/file str)]
       (if (.isFile f)
         (read-edn-file f)
         (cljs.cli/missing-file str))))))

(defn merge-meta [m m1] (with-meta (merge m m1) (merge (meta m) (meta m1))))

(defn load-edn-opts [str]
  (reduce merge-meta {} (map read-edn-opts (cljs.util/split-paths str))))

(defn fallback-id [edn]
  (let [m (meta edn)]
    (cond
      (and (:id m) (not (string/blank? (str (:id m)))))
      (:id m)
      ;;(:main edn)      (munge (str (:main edn)))
      :else
      (str "build-"
           (.getValue (doto (java.util.zip.CRC32.)
                        (.update (.getBytes (pr-str (into (sorted-map) edn))))))))))

(defn compile-opts-opt
  [cfg copts]
  (let [copts (string/trim copts)
        edn   (if (or (string/starts-with? copts "{")
                      (string/starts-with? copts "^"))
                (read-edn-string copts "Error reading EDN from command line flag: -co ")
                (load-edn-opts copts))
        config  (meta edn)
        id
        (and edn
             (if (or (string/starts-with? copts "{")
                     (string/starts-with? copts "^"))
               (and (map? edn) (fallback-id edn))
               (->>
                (cljs.util/split-paths copts)
                (filter (complement string/blank?))
                (filter #(not (.startsWith % "@")))
                (map io/file)
                (map (comp first #(string/split % #"\.") #(.getName %)))
                (string/join ""))))]
    (log/debug "Validating options passed to --compile-opts")
    (validate-config!
     :figwheel.main.schema.cljs-options/cljs-options
     edn
     (str "Configuration error in options passed to --compile-opts"))
    (cond-> cfg
      edn (update :options merge edn)
      id  (update-in [::build :id] #(if-not % id %))
      config (update-in [::build :config] merge config))))

(defn repl-env-opts-opt
  [cfg ropts]
  (let [ropts (string/trim ropts)
        edn   (if (string/starts-with? ropts "{")
                (read-edn-string ropts "Error reading EDN from command line flag: --repl-opts ")
                (load-edn-opts ropts))]
    (update cfg :repl-env-options merge edn)))

(defn figwheel-opts-opt
  [cfg ropts]
  (let [ropts (string/trim ropts)
        edn   (if (string/starts-with? ropts "{")
                (read-edn-string ropts "Error reading EDN from command line flag: -fw-opts ")
                (load-edn-opts ropts))]
    (validate-config!
     :figwheel.main.schema.config/edn
     edn "Error validating figwheel options EDN provided to -fwo CLI flag")
    (update cfg ::config merge edn)))

(defn print-config-opt [cfg opt]
  (assoc-in cfg [::config :pprint-config] (not (#{"false"} opt))))

(defn- watch-opt
  [cfg path]
  (when-not (.exists (io/file path))
    (if (or (string/starts-with? path "-")
            (string/blank? path))
      (throw
        (ex-info
          (str "Missing watch path")
          {:cljs.main/error :invalid-arg}))
      (throw
        (ex-info
          (str "Watch path \"" path "\" does not exist")
          {:cljs.main/error :invalid-arg}))))
  (update-in cfg [::extra-config :watch-dirs] (fnil conj []) path))

(defn figwheel-opt [cfg bl]
  (assoc-in cfg [::config :figwheel-core] (not= bl "false")))

(defn get-build [bn]
  (let [fname (if (.contains bn (System/getProperty "path.separator"))
                bn
                (str bn ".cljs.edn"))
        build (->> (cljs.util/split-paths bn)
                   (map #(str % ".cljs.edn"))
                   (string/join (System/getProperty "path.separator"))
                   load-edn-opts)]
    (when build
      (when-not (false? (:validate-config (meta build)))
        (when (meta build)
          (log/debug "Validating metadata in build: " fname)
          (validate-config!
           :figwheel.main.schema.config/edn
           (meta build)
           (str "Configuration error in build options meta data: " fname)))
        (log/debug "Validating CLJS compile options for build:" fname)
        (validate-config!
         :figwheel.main.schema.cljs-options/cljs-options
         build
         (str "Configuration error in CLJS compile options: " fname))))
    build))

(defn watch-dir-from-ns [main-ns]
  (let [source (fw-util/ns->location main-ns)]
    (when-let [f (:uri source)]
      (when (= "file" (.getScheme (.toURI f)))
        (let [res (fw-util/relativized-path-parts (.getPath f))
              end-parts (fw-util/path-parts (:relative-path source))]
          (when (= end-parts (take-last (count end-parts) res))
            (str (apply io/file (drop-last (count end-parts) res)))))))))

(def default-main-repl-index-body
  (str
   "<p>Welcome to the Figwheel REPL page.</p>"
   "<p>This page is served when you launch <code>figwheel.main</code> without any command line arguments.</p>"
   "<p>This page is currently hosting your REPL and application evaluation environment. "
   "Validate the connection by typing <code>(js/alert&nbsp;\"Hello&nbsp;Figwheel!\")</code> in the REPL.</p>"))

(defn get-build-with-error [bn]
  (when-not (.exists (io/file (str bn ".cljs.edn")))
    (if (or (string/starts-with? bn "-")
            (string/blank? bn))
      (throw
        (ex-info
          (str "Missing build name")
          {:cljs.main/error :invalid-arg}))
      (throw
        (ex-info
          (str "Build " (str bn ".cljs.edn") " does not exist")
          {:cljs.main/error :invalid-arg}))))
  (get-build bn))

(defn build-opt [cfg bn]
  (let [bns (string/split bn #":")
        id  (string/join "" bns)
        options (->> bns
                     (map get-build-with-error)
                     (reduce merge-meta))]
    (-> cfg
        (update :options merge options)
        (assoc  ::build (cond-> {:id id}
                          (meta options)
                          (assoc :config (meta options)))))))

(defn build-once-opt [cfg bn]
  (let [cfg (build-opt cfg bn)]
    (assoc-in cfg [::config ::build-once] true)))

(defn background-build-opt [cfg bn]
  (let [{:keys [options ::build]} (build-opt {} bn)]
    (update cfg ::background-builds
            (fnil conj [])
            (assoc build :options options))))

;; TODO move these down to main action section

(declare default-compile)

(defn build-main-opt [repl-env-fn [_ build-name & args] cfg]
  ;; serve if no other args
  (let [args (if-not (#{"-s" "-r" "--repl" "--serve"} (first args))
               (cons "-s" args)
               args)]
    (default-compile repl-env-fn
                     (merge (build-opt cfg build-name)
                            {:args args
                             ::build-main-opt true}))))

(defn build-once-main-opt [repl-env-fn [_ build-name & args] cfg]
  (default-compile repl-env-fn
                   (merge (build-once-opt cfg build-name)
                          {:args args})))

(declare default-output-dir default-output-to)

(defn make-temp-dir []
  (let [tempf (java.io.File/createTempFile "figwheel" "repl")]
    (.delete tempf)
    (.mkdirs tempf)
    (.deleteOnExit (io/file tempf))
    (fw-util/add-classpath! (.toURL tempf))
    tempf))

(defn add-temp-dir [cfg]
  (let [temp-dir (make-temp-dir)
        config-with-target (assoc-in cfg [::config :target-dir] temp-dir)
        output-dir (default-output-dir config-with-target)
        output-to  (default-output-to config-with-target)]
    (-> cfg
        (assoc-in [:options :output-dir] output-dir)
        (assoc-in [:options :output-to]  output-to)
        (assoc-in [:options :asset-path]
                  (str "/cljs-out"
                       (when-let [id (-> cfg ::build :id)]
                         (str "/" id)))))))

(defn should-add-temp-dir? [cfg]
  (let [target-on-classpath?
        (when-let [target-dir (get-edn-file-key
                               "figwheel-main.edn"
                               :target-dir
                               default-target-dir)]
          (fw-util/dir-on-classpath? target-dir))]
    (and (nil? (:target (:options cfg)))
         (not target-on-classpath?))))

(defn helper-ring-app [handler html-body output-to & [force-index?]]
  (figwheel.server.ring/default-index-html
   handler
   (figwheel.server.ring/index-html (cond-> {}
                                      html-body (assoc :body html-body)
                                      output-to (assoc :output-to output-to)))
   force-index?))

(defn repl-main-opt [repl-env-fn args cfg]
  (let [cfg (if (should-add-temp-dir? cfg)
              (add-temp-dir cfg)
              cfg)
        cfg (if (get-in cfg [::build :id])
              cfg
              (assoc-in cfg [::build :id] "figwheel-default-repl-build"))
        output-to (get-in cfg [:options :output-to]
                          (default-output-to cfg))]
    (default-compile
     repl-env-fn
     (-> cfg
         (assoc :args args)
         (update :options (fn [opt] (merge {:main 'figwheel.repl.preload} opt)))
         (assoc-in [:options :aot-cache] true)
         (assoc-in [::config
                    :ring-stack-options
                    :figwheel.server.ring/dev
                    :figwheel.server.ring/system-app-handler]
                   #(helper/middleware
                     %
                     {:header "REPL Host page"
                      :body (slurp (io/resource "public/com/bhauman/figwheel/helper/content/repl_welcome.html"))
                      :output-to output-to}))
         (assoc-in [::config :mode] :repl)))))

(declare serve update-config)

(defn print-conf [cfg]
  (println "---------------------- Figwheel options ----------------------")
  (pprint (::config cfg))
  (println "---------------------- Compiler options ----------------------")
  (pprint (:options cfg)))

(defn serve-main-opt [repl-env-fn args b-cfg]
  (let [{:keys [repl-env-options repl-options options] :as cfg}
        (-> b-cfg
            (assoc :args args)
            update-config)
        repl-env-options
        (update-in
         repl-env-options
         [:ring-stack-options
          :figwheel.server.ring/dev
          :figwheel.server.ring/system-app-handler]
         (fn [sah]
           (if sah
             sah
             #(helper/serve-only-middleware % {}))))
        {:keys [pprint-config]} (::config cfg)
        repl-env (apply repl-env-fn (mapcat identity repl-env-options))]
    (log/trace "Verbose config:" (with-out-str (pprint cfg)))
    (if pprint-config
      (do
        (log/info ":pprint-config true - printing config:")
        (print-conf cfg))
      (serve {:repl-env repl-env
              :repl-options repl-options
              :join? true}))))

(def figwheel-commands
  {:init {["-w" "--watch"]
          {:group :cljs.cli/compile :fn watch-opt
           :arg "path"
           :doc "Continuously build, only effective with the --compile and --build main options"}
          ["-fwo" "--fw-opts"]
          {:group :cljs.cli/compile :fn figwheel-opts-opt
           :arg "edn"
           :doc (str "Options to configure figwheel.main, can be an EDN string or "
                     "system-dependent path-separated list of EDN files / classpath resources. Options "
                     "will be merged left to right.")}
          ["-ro" "--repl-opts"]
          {:group ::main&compile :fn repl-env-opts-opt
           :arg "edn"
           :doc (str "Options to configure the repl-env, can be an EDN string or "
                     "system-dependent path-separated list of EDN files / classpath resources. Options "
                     "will be merged left to right.")}
          ["-co" "--compile-opts"]
          {:group :cljs.cli/main&compile :fn compile-opts-opt
           :arg "edn"
           :doc (str "Options to configure the build, can be an EDN string or "
                     "system-dependent path-separated list of EDN files / classpath resources. Options "
                     "will be merged left to right. Any meta data will be merged with the figwheel-options.")}
          ;; TODO uncertain about this
          ["-fw" "--figwheel"]
          {:group :cljs.cli/compile :fn figwheel-opt
           :arg "bool"
           :doc (str "Use Figwheel to auto reload and report compile info. "
                     "Only takes effect when watching is happening and the "
                     "optimizations level is :none or nil."
                     "Defaults to true.")}
          ["-bb" "--background-build"]
          {:group :cljs.cli/compile :fn background-build-opt
           :arg "str"
           :doc "The name of a build config to watch and build in the background."}
          ["-pc" "--print-config"]
          {:group :cljs.cli/main&compile :fn print-config-opt
           :doc "Instead of running the command print out the configuration built up by the command. Useful for debugging."}
          }
   :main {["-b" "--build"]
          {:fn build-main-opt
           :arg "string"
           :doc (str "Run a compile process. The supplied build name or a list of build names "
                     "(seperated by \":\") refer to "
                     "EDN files of compile options "
                     "IE. If you use \"dev\" as a build name it will indicate "
                     "that a \"dev.cljs.edn\" will be read for "
                     "compile options. "
                     "Multiple build names will merged left to right along with their metadata. "
                     "The --build option will make an "
                     "extra attempt to "
                     "initialize a figwheel live reloading workflow. "
                     "May be followed buy either --repl or --server. "
                     "If --repl follows, "
                     "will launch a REPL (along with a server) after the compile completes. "
                     "If --server follows, will only start a web server according to "
                     "current configuration after the compile "
                     "completes.")}
          ["-bo" "--build-once"]
          {:fn build-once-main-opt
           :arg "string"
           :doc (str "Compile for the build name one time. "
                     "Looks for build EDN files just like the --build command. "
                     "This will not inject Figwheel or REPL functionality into your build. "
                     "It will still inject devtools if you are using :optimizations :none. "
                     "If --server follows, will start a web server according to "
                     "current configuration after the compile "
                     "completes.")}
          ["-r" "--repl"]
          {:fn repl-main-opt
           :doc "Run a REPL"}
          ["-s" "--serve"]
          {:fn serve-main-opt
           :arg "host:port"
           :doc "Run a server based on the figwheel-main configuration options."}
          ["-h" "--help" "-?"]
          {:fn help-opt
           :doc "Print this help message and exit"}
          }})

;; ----------------------------------------------------------------------------
;; Config
;; ----------------------------------------------------------------------------

(defn default-output-dir* [target & [scope]]
  (->> (cond-> [(or target default-target-dir) "public" "cljs-out"]
         scope (conj scope))
       (apply io/file)
       (.getPath)))

(defmulti default-output-dir (fn [{:keys [options]}]
                               (get options :target :browser)))

(defmethod default-output-dir :default [{:keys [::config ::build]}]
  (default-output-dir* (:target-dir config) (:id build)))

(defmethod default-output-dir :nodejs [{:keys [::config ::build]}]
  (let [target (:target-dir config default-target-dir)
        scope (:id build)]
    (->> (cond-> [target "node"]
           scope (conj scope))
         (apply io/file)
         (.getPath))))

(defn default-output-to* [target & [scope]]
  (.getPath (io/file (or target default-target-dir) "public" "cljs-out"
                     (cond->> "main.js"
                       scope (str scope "-")))))

(defmulti default-output-to (fn [{:keys [options]}]
                              (get options :target :browser)))

(defmethod default-output-to :default [{:keys [::config ::build]}]
  (default-output-to* (:target-dir config) (:id build)))

(defmethod default-output-to :nodejs [{:keys [::build] :as cfg}]
  (let [scope (:id build)]
    (.getPath (io/file (default-output-dir cfg)
                       (cond->> "main.js"
                         scope (str scope "-"))))))

(defn extra-config-merge [a' b']
  (merge-with (fn [a b]
                (cond
                  (and (map? a) (map? b)) (merge a b)
                  (and (sequential? a)
                       (sequential? b))
                  (distinct (concat a b))
                  (nil? b) a
                  :else b))
              a' b'))

(defn resolve-fn-var [prefix handler]
  (if (or (nil? handler) (var? handler))
    handler
    (let [prefix (when prefix (str prefix ": "))]
      (when (and handler (nil? (namespace (symbol handler))))
        (throw
         (ex-info
          (format "%sThe var '%s has the wrong form it must be a namespaced symbol" prefix
                  (pr-str handler))
          {::error true :handler handler})))
      (let [handler-res (fw-util/require-resolve-handler-or-error handler)]
        (when (and handler (not handler-res))
          (throw (ex-info
                  (format "%sWas able to load namespace '%s but unable to resolve the specific var: '%s"
                          prefix
                          (namespace (symbol handler))
                          (str handler))
                  {::error true
                   :handler handler})))
        (when (map? handler-res)
          (letfn [(error [s]
                    (throw (ex-info s {::error true :handler handler})))]
            (condp = (:stage handler-res)
              :bad-namespaced-symbol
              (do (log/syntax-exception (:exception handler-res))
                  (error (format "%sThere was an error while trying to resolve '%s"
                                 prefix
                                 (pr-str handler))))
              :unable-to-resolve-handler-fn
              (error (format "%sWas able to load namespace '%s but unable to resolve the specific var: '%s"
                             prefix
                             (namespace (symbol handler))
                             (str handler)))
              :unable-to-load-handler-namespace
              (do
                (log/syntax-exception (:exception handler-res))
                (error (format "%sThere was an exception while requiring the namespace '%s while trying to load the var '%s"
                               prefix
                               (namespace (symbol handler))
                               (str handler)))))))
        handler-res))))

(defn resolve-ring-handler [ring-handler]
  (resolve-fn-var "ring-handler" ring-handler))

(defn process-main-config [{:keys [ring-handler] :as main-config}]
  (let [handler (resolve-ring-handler ring-handler)]
    (cond-> main-config
      handler (assoc :ring-handler handler))))

(defn process-figwheel-main-edn [main-edn]
  (when main-edn
    (when-not (false? (:validate-config main-edn))
      (log/info "Validating figwheel-main.edn")
      (validate-config!
       :figwheel.main.schema.config/edn
       main-edn "Configuration error in figwheel-main.edn"
       "figwheel-main.edn is valid \\(ツ)/"))
    (process-main-config main-edn)))

;; use tools reader read-string for better error messages
#_(redn/read-string)
(defn fetch-figwheel-main-edn [cfg]
  (when (.isFile (io/file "figwheel-main.edn"))
    (read-edn-file "figwheel-main.edn")))

(defn- config-figwheel-main-edn [cfg]
  (let [config-edn (process-figwheel-main-edn
                    (or (::start-figwheel-options cfg)
                        (fetch-figwheel-main-edn cfg)))]
    (cond-> cfg
      config-edn (update ::config #(merge config-edn %)))))

(defn- config-merge-current-build-conf [{:keys [::extra-config ::build] :as cfg}]
  (update cfg
          ::config #(extra-config-merge
                     (merge-with (fn [a b] (if b b a)) %
                                 (process-main-config (:config build)))
                     extra-config)))

(defn host-port-arg? [arg]
  (and arg (re-matches #"(.*):(\d*)" arg)))

(defn update-server-host-port [config [f address-port & args]]
  (if (and (#{"-s" "--serve"} f) address-port)
    (let [[_ host port] (host-port-arg? address-port)]
      (cond-> config
        (not (string/blank? host)) (assoc-in [:ring-server-options :host] host)
        (not (string/blank? port)) (assoc-in [:ring-server-options :port] (Integer/parseInt port))))
    config))

;; targets options
(defn- config-main-ns [{:keys [ns options] :as cfg}]
  (let [main-ns (if (and ns (not (#{"-r" "--repl" "-s" "--serve"} ns)))
                  (symbol ns)
                  (:main options))]
    (cond-> cfg
      main-ns (assoc :ns main-ns)       ;; TODO not needed?
      main-ns (assoc-in [:options :main] main-ns))))

(defn warn-that-dir-not-on-classpath [typ dir]
  (let [[n k] (condp = typ
                :source ["Source directory" :source-paths]
                :target ["Target directory" :resource-paths])]
    (log/warn (ansip/format-str
               [:yellow n " "
                (pr-str (str dir))
                " is not on the classpath"]))
    (log/warn "Please fix this by adding" (pr-str (str dir))
              "to your classpath\n"
              "I.E.\n"
              "For Clojure CLI Tools in your deps.edn file:\n"
              "   ensure" (pr-str (str dir))
              "is in your :paths key\n\n"
              (when k
                (format
                 (str "For Leiningen in your project.clj:\n"
                      "   add it to the %s key\n")
                 (pr-str k))))))

;; takes a string or file representation of a directory
(defn- add-classpath! [dir]
  (when-not (fw-util/dir-on-classpath? dir)
    (log/warn (ansip/format-str [:yellow
                                 (format "Attempting to dynamically add %s to classpath!"
                                 (pr-str (str dir)))]))
    (fw-util/add-classpath! (.toURL (io/file dir)))))

(defn- config-main-source-path-on-classpath [{:keys [options] :as cfg}]
  (when-let [main (:ns cfg)]
    (when-not (fw-util/safe-ns->location main)
      (when-let [src-dir (fw-util/find-source-dir-for-cljs-ns main)]
        (when-not (fw-util/dir-on-classpath? src-dir)
          (if (get-in cfg [::config :helpful-classpaths] true)
            (do
              (add-classpath! src-dir)
              (warn-that-dir-not-on-classpath :source src-dir))
            (log/warn (ansip/format-str
                       [:yellow
                        "The source directory for the main ns "
                        (pr-str (str src-dir))
                        " is not the classpath!"])))))))
  cfg)

;; targets local config
(defn- config-repl-serve? [{:keys [ns args] :as cfg}]
  (let [rfs      #{"-r" "--repl"}
        sfs      #{"-s" "--serve"}]
    (cond-> cfg
      (boolean (or (rfs ns) (rfs (first args))))
      (assoc-in [::config :mode] :repl)
      (boolean (or (sfs ns) (sfs (first args))))
      (->
       (assoc-in [::config :mode] :serve)
       (update ::config update-server-host-port args))
      (rfs (first args))
      (update :args rest)
      (sfs (first args))
      (update :args rest)
      (and (sfs (first args)) (host-port-arg? (second args)))
      (update :args rest))))

;; targets local config
(defn- config-update-watch-dirs [{:keys [options ::config] :as cfg}]
  ;; remember we have to fix this for the repl-opt fn as well
  ;; so that it understands multiple watch directories
  (update-in cfg [::config :watch-dirs]
            #(not-empty
              (distinct
               (let [ns-watch-dir (and
                                   (#{:repl :serve} (:mode config))
                                   (not (::build-once config))
                                   (not (:watch options))
                                   (empty? %)
                                   (:main options)
                                   (watch-dir-from-ns (:main options)))]
                 (cond-> %
                   (:watch options) (conj (:watch options))
                   ns-watch-dir (conj ns-watch-dir)))))))

(defn- config-ensure-watch-dirs-on-classpath [{:keys [::config] :as cfg}]
  (doseq [src-dir (:watch-dirs config)]
    (when-not (fw-util/dir-on-current-classpath? src-dir)
      (log/warn (ansip/format-str
                 [:yellow
                  "The watch directory "
                  (pr-str (str src-dir))
                  " is not the classpath! A watch directory is must "
                  "on the classpath and point to the root directory of your namespace "
                  "source tree. A general all encompassing watch directory will not work."]))
      (when (get config :helpful-classpaths true)
        (add-classpath! src-dir)
        (warn-that-dir-not-on-classpath :source src-dir)))) cfg)

;; needs local config
(defn figwheel-mode? [{:keys [::config options]}]
  (and (:figwheel-core config true)
       (and (#{:repl :serve} (:mode config))
            (not (::build-once config))
            (not-empty (:watch-dirs config)))
       (= :none (:optimizations options :none))))

(defn repl-connection? [{:keys [::config options] :as cfg}]
  (or (and (#{:repl :serve} (:mode config))
           (not (::build-once config))
           (= :none (:optimizations options :none)))
      (figwheel-mode? cfg)))

;; TODO this is a no-op right now
(defn prep-client-config [config]
  (let [cl-config (select-keys config [])]
    cl-config))

;; targets options needs local config
(defn- config-figwheel-mode? [{:keys [::config options] :as cfg}]
  (cond-> cfg
    ;; check for a main??
    (figwheel-mode? cfg)
    (->
     (update ::initializers (fnil conj []) #(figwheel.core/start*))
     (update-in [:options :preloads]
                (fn [p]
                  (vec (distinct
                        (concat p '[figwheel.core figwheel.main]))))))
    (false? (:heads-up-display config))
    (update-in [:options :closure-defines] assoc 'figwheel.core/heads-up-display false)
    (true? (:load-warninged-code config))
    (update-in [:options :closure-defines] assoc 'figwheel.core/load-warninged-code true)))

(defn- modules-output-to [{:keys [options ::config ::build] :as cfg}]
  (if (not-empty (:modules options))
    (update-in
     cfg [:options :modules]
     #(->> %
           (map (fn [[k v]]
                  (if-not (:output-to v)
                    [k (assoc v :output-to
                              (string/replace
                               (default-output-to cfg)
                               "main.js" ;; brittle
                               (str (name k) ".js")))]
                    [k v])))
           (into {})))
    cfg))

;; targets options
;; TODO needs to consider case where one or the other is specified???
(defn- config-default-dirs [{:keys [options ::config ::build] :as cfg}]
  (cond-> cfg
    (and (nil? (:output-to options)) (not (:modules options)))
    (assoc-in [:options :output-to] (default-output-to cfg))
    (:modules options)
    modules-output-to
    (nil? (:output-dir options))
    (assoc-in [:options :output-dir] (default-output-dir cfg))))

(defn figure-default-asset-path [{:keys [figwheel-options options ::config ::build] :as cfg}]
  (if (= :nodejs (:target options))
    (:output-dir options)
    (let [{:keys [output-dir]} options]
      ;; TODO could discover the resource root if there is only one
      ;; or if ONLY static file serving can probably do something with that
      ;; as well
      ;; UNTIL THEN if you have configured your static resources no default asset-path
      (when-not (contains? (:ring-stack-options figwheel-options) :static)
        (let [parts (fw-util/relativized-path-parts (or output-dir
                                                        (default-output-dir cfg)))]
          (when-let [asset-path
                     (->> parts
                          (split-with (complement #{"public"}))
                          last
                          rest
                          not-empty)]
            (str "/" (string/join "/" asset-path))))))))

;; targets options
(defn- config-default-asset-path [{:keys [options] :as cfg}]
  (cond-> cfg
    (nil? (:asset-path options))
    (assoc-in [:options :asset-path] (figure-default-asset-path cfg))))

;; targets options
(defn- config-default-aot-cache-false [{:keys [options] :as cfg}]
  (cond-> cfg
    (not (contains? options :aot-cache))
    (assoc-in [:options :aot-cache] false)))

(defn config-clean [cfg]
  (update cfg :options dissoc :watch))

;; TODO create connection

(let [localhost (promise)]
  ;; this call takes a very long time to complete so lets get in in parallel
  (doto (Thread. #(deliver localhost (try (java.net.InetAddress/getLocalHost)
                                          (catch Throwable e
                                            nil))))
    (.setDaemon true)
    (.start))
  (defn fill-connect-url-template [url host server-port]
    (cond-> url
      (.contains url "[[config-hostname]]")
      (string/replace "[[config-hostname]]" (or host "localhost"))

      (.contains url "[[server-hostname]]")
      (string/replace "[[server-hostname]]" (or (some-> @localhost
                                                        .getHostName)
                                                "localhost"))

      (.contains url "[[server-ip]]")
      (string/replace "[[server-ip]]"       (or (some-> @localhost
                                                        .getHostAddress)
                                                "127.0.0.1"))

      (.contains url "[[server-port]]")
      (string/replace "[[server-port]]"     (str server-port)))))

(defn add-to-query [uri query-map]
  (let [[pre query] (string/split uri #"\?")]
    (str pre
         (when (or query (not-empty query-map))
             (str "?"
              (string/join "&"
                           (map (fn [[k v]]
                                  (str (name k)
                                       "="
                                       (java.net.URLEncoder/encode (str v) "UTF-8")))
                                query-map))
              (when (not (string/blank? query))
                (str "&" query)))))))

#_(add-to-query "ws://localhost:9500/figwheel-connect?hey=5" {:ab 'ab})

(defn config-connect-url [{:keys [::config repl-env-options] :as cfg} connect-id]
  (let [port (get-in config [:ring-server-options :port] figwheel.repl/default-port)
        host (get-in config [:ring-server-options :host] "localhost")
        connect-url
        (fill-connect-url-template
         (:connect-url config "ws://[[config-hostname]]:[[server-port]]/figwheel-connect")
         host
         port)]
    (add-to-query connect-url connect-id)))

#_(config-connect-url {} {:abb 1})

(defn config-repl-connect [{:keys [::config options ::build] :as cfg}]
  (let [connect-id (:connect-id config
                                (cond-> {:fwprocess process-unique}
                                  (:id build) (assoc :fwbuild (:id build))))
        conn-url (config-connect-url cfg connect-id)
        conn? (repl-connection? cfg)]
    (cond-> cfg
      conn?
      (update-in [:options :closure-defines] assoc 'figwheel.repl/connect-url conn-url)
      conn?
      (update-in [:options :preloads]
                 (fn [p]
                   (vec (distinct
                         (concat p '[figwheel.repl.preload])))))
      conn?
      (update-in [:options :repl-requires] into '[[cljs.repl :refer-macros [source doc find-doc apropos dir pst]]
                                                  [cljs.pprint :refer [pprint] :refer-macros [pp]]
                                                  [figwheel.main :refer-macros [stop-builds start-builds build-once reset clean status]]
                                                  [figwheel.repl :refer-macros [conns focus]]])
      (and conn? (:client-print-to config))
      (update-in [:options :closure-defines] assoc
                 'figwheel.repl/print-output
                 (string/join "," (distinct (map name (:client-print-to config)))))
      (and conn? (:client-log-level config))
      (update-in [:options :closure-defines] assoc
                 'figwheel.repl/client-log-level
                 (name (:client-log-level config)))
      (and conn? (not-empty (:watch-dirs config)))
      (update-in [:repl-options :analyze-path] (comp vec concat) (:watch-dirs config))
      (and conn? (not-empty connect-id))
      (assoc-in [:repl-env-options :connection-filter]
                (let [kys (keys connect-id)]
                  (fn [{:keys [query]}]
                    (if (not (:fwprocess query))
                      (= (:fwbuild query)
                         (:fwbuild connect-id))
                      (= (select-keys query kys)
                         connect-id))))))))

(defn config-cljs-devtools [{:keys [::config options] :as cfg}]
  (if (and
       (nil? (:target options))
       (= :none (:optimizations options :none))
       (:cljs-devtools config true)
       (try (bapi/ns->location 'devtools.preload) (catch Throwable t false)))
    (update-in cfg
               [:options :preloads]
               (fn [p]
                 (vec (distinct
                       (concat p '[devtools.preload])))))
    cfg))

(defn config-open-file-command [{:keys [::config options] :as cfg}]
  (if-let [setup (and (:open-file-command config)
                      (repl-connection? cfg)
                      (fw-util/require-resolve-var 'figwheel.main.editor/setup))]
    (-> cfg
        (update ::initializers (fnil conj []) #(setup (:open-file-command config)))
        (update-in [:options :preloads]
                   (fn [p] (vec (distinct (conj p 'figwheel.main.editor))))))
    cfg))

(defn config-eval-back [{:keys [::config options] :as cfg}]
  (if-let [setup (and (repl-connection? cfg)
                      (fw-util/require-resolve-var 'figwheel.main.evalback/setup))]
    (-> cfg
        (update ::initializers (fnil conj []) #(setup))
        (update-in [:options :preloads]
                   (fn [p] (vec (distinct (concat p '[figwheel.main.evalback #_figwheel.main.testing]))))))
    cfg))

(defn watch-css [css-dirs]
  (when-let [css-dirs (not-empty css-dirs)]
    (when-let [start-css (fw-util/require-resolve-var 'figwheel.main.css-reload/start*)]
      (start-css css-dirs))))

(defn config-watch-css [{:keys [::config options] :as cfg}]
  (cond-> cfg
    (and (not-empty (:css-dirs config))
         (repl-connection? cfg))
    (->
     (update ::initializers (fnil conj []) #(watch-css (:css-dirs config)))
     (update-in [:options :preloads]
                (fn [p] (vec (distinct (conj p 'figwheel.main.css-reload))))))))

(defn get-repl-options [{:keys [options args inits repl-options] :as cfg}]
  (assoc (merge (dissoc options :main)
                repl-options)
         :inits
         (into
          [{:type :init-forms
            :forms (when-not (empty? args)
                     [`(set! *command-line-args* (list ~@args))])}]
          inits)))

(defn get-repl-env-options [{:keys [repl-env-options ::config options] :as cfg}]
  (let [repl-options (get-repl-options cfg)]
    (merge
     (select-keys config
                  [:ring-server
                   :ring-server-options
                   :ring-stack
                   :ring-stack-options
                   :ring-handler
                   :launch-node
                   :inspect-node
                   :node-command
                   :broadcast
                   :open-url
                   :launch-js
                   :repl-eval-timeout])
     repl-env-options ;; from command line
     (select-keys options [:output-to :output-dir :target]))))

(defn config-finalize-repl-options [cfg]
  (let [repl-options (get-repl-options cfg)
        repl-env-options (get-repl-env-options cfg)]
    (assoc cfg
           :repl-options repl-options
           :repl-env-options repl-env-options)))

(defn config-set-log-level! [{:keys [::config] :as cfg}]
  (when-let [log-level (:log-level config)]
    (log/set-level log-level))
  cfg)

(defn config-ansi-color-output! [{:keys [::config] :as cfg}]
  (when (some? (:ansi-color-output config))
    (alter-var-root #'ansip/*use-color* (fn [_] (:ansi-color-output config))))
  cfg)

(defn config-log-syntax-error-style! [{:keys [::config] :as cfg}]
  (when (some? (:log-syntax-error-style config))
    (alter-var-root #'log/*syntax-error-style* (fn [_] (:log-syntax-error-style config))))
  cfg)

(defn- config-warn-resource-directory-not-on-classpath [{:keys [::config options] :as cfg}]
  ;; this could check for other directories than resources
  ;; but this is mainly to help newcomers
  (when (and (nil? (:target options))
             (or (and (::build-once config)
                      (#{:serve} (:mode config)))
                 (#{:repl :serve} (:mode config)))
             (.isFile (io/file "resources/public/index.html"))
             (not (fw-util/dir-on-classpath? "resources")))
    (log/warn (ansip/format-str
               [:yellow "A \"resources/public/index.html\" exists but the \"resources\" directory is not on the classpath\n"
                "    the default server will not be able to find your index.html"])))
  cfg)

(defn config-pre-post-hooks [{:keys [::config] :as cfg}]
  (cond-> cfg
    (not-empty (:pre-build-hooks config))
    (update ::pre-build-hooks concat
            (doall
             (keep (partial resolve-fn-var "pre-build-hook-fn")
                   (:pre-build-hooks config))))
    (not-empty (:post-build-hooks config))
    (update ::post-build-hooks concat
            (doall
             (keep (partial resolve-fn-var "post-build-hook-fn")
                   (:post-build-hooks config))))))

(defn alter-output-to [nm {:keys [output-to output-dir] :as opts}]
  (cond
    output-to
    (let [f (io/file output-to)
          fname (string/replace (.getName f) #"\.js$" "")]
      (assoc opts :output-to
             (str (io/file (.getParent f) (str fname "-" nm ".js")))))
    output-dir
    (assoc opts :output-to (str (io/file output-dir (str "main-" nm ".js"))))
    :else nil))

(defn merge-extra-key-with [m extra-m f k]
  (if-let [value (get extra-m k)]
    (let [act-key (keyword (string/replace (name k) #"^extra-" "")) ]
      (update m act-key f value))
    m))

(defn merge-extra-cljs-options
  "Merges ClojureScript options that are collections if they are
  prepended with :extra."
  [opts extra-opts]
  (let [coll-keys [:extra-foreign-libs
                   :extra-externs
                   :extra-preloads
                   :extra-closure-extra-annotations]
        map-keys [:extra-modules
                  :extra-npm-deps
                  :extra-closure-defines
                  :extra-closure-warnings]]
    (as-> (merge opts extra-opts) opts
      (apply dissoc opts
             (concat coll-keys map-keys
                     [:extra-warnings]))
      (merge-extra-key-with opts extra-opts (fn [x y]
                                              (merge (if (boolean? x) {} x) y)) :extra-warnings)
      (reduce #(merge-extra-key-with %1 extra-opts (comp vec concat) %2) opts coll-keys)
      (reduce #(merge-extra-key-with %1 extra-opts merge %2) opts map-keys))))

(defn extra-main-options [nm em-options options]
  ;; need to remove modules so that we get a funcitioning independent main endpoint
  (merge-extra-cljs-options
   (dissoc (alter-output-to (name nm) options) :modules)
   em-options))

(defn extra-main-fn [nm em-options options]
  ;; TODO modules??
  (let [opts (extra-main-options nm em-options options)]
    (fn [_]
      (log/info (format "Outputting main file: %s" (:output-to opts "main.js")))
      (cljs.closure/output-main-file
       (cljs.closure/add-implicit-options
        opts)))))

(defn config-extra-mains [{:keys [::config options] :as cfg}]
  (let [{:keys [extra-main-files]} config]
    (if (and (not-empty extra-main-files)
             (= :none (:optimizations options :none)))
      (update cfg ::post-build-hooks
              concat (map (fn [[k v]]
                            (extra-main-fn k v options))
                          extra-main-files))
      cfg)))

(defn expand-build-inputs [{:keys [watch-dirs build-inputs] :as config} {:keys [main] :as options}]
  (doall
   (distinct
    (mapcat
     (fn [x]
       (cond
         (= x :main)
         (when-let [{:keys [uri]} (and main (fw-util/ns->location (symbol main)))]
           [uri])
         (symbol? x)
         (when-let [{:keys [uri]} (fw-util/ns->location x)]
           [uri])
         (= x :watch-dirs)
         watch-dirs
         :else [x]))
     build-inputs))))

(defn config->inputs [{:keys [watch-dirs mode build-inputs ::build-once] :as config} options]
  (if (not-empty build-inputs)
    (expand-build-inputs config options)
    (if-let [inputs (and (not build-once)
                         (= :none (:optimizations options :none))
                         (not-empty watch-dirs))]
      inputs
      (let [source (when (:main options)
                     (:uri (fw-util/ns->location (symbol (:main options)))))]
        (cond
          source [source]
          (not-empty watch-dirs) watch-dirs)))))

(defn config-build-inputs [{:keys [options ::config] :as cfg}]
  (if-let [inputs (not-empty (config->inputs config options))]
    (update-in cfg [::config ::build-inputs] (comp vec distinct concat) inputs)
    cfg))

(defn config-compile-is-build-once [{:keys [args] :as cfg}]
  (cond-> cfg
    (and (= (set (keys cfg)) #{:args :ns})
         (not (#{"-r" "--repl" "-s" "--serve"} (first args))))
    (assoc-in [::config ::build-once] true)))

(defn update-config [cfg]
  (->> cfg
       config-compile-is-build-once
       config-figwheel-main-edn
       config-merge-current-build-conf
       config-ansi-color-output!
       config-set-log-level!
       config-log-syntax-error-style!
       config-repl-serve?
       config-main-ns
       config-main-source-path-on-classpath

       config-update-watch-dirs
       config-ensure-watch-dirs-on-classpath
       config-figwheel-mode?
       config-default-dirs
       config-default-asset-path
       config-default-aot-cache-false
       npm/config
       testing/plugin
       config-pre-post-hooks
       config-repl-connect
       config-cljs-devtools
       config-open-file-command
       #_config-eval-back
       config-watch-css
       config-finalize-repl-options
       config-extra-mains
       config-build-inputs
       config-clean
       config-warn-resource-directory-not-on-classpath))

;; ----------------------------------------------------------------------------
;; Main action
;; ----------------------------------------------------------------------------

(defn build [{:keys [watch-dirs mode ::build-once ::build-inputs] :as config}
             options cenv]
  (let [id (:id (::build *config*) "unknown")]
    (assert (not-empty build-inputs) "Should have at least one build input!")
    (build-cljs id (apply bapi/inputs build-inputs) options cenv)
    ;; are we watching?
    (when-let [paths (and (not build-once)
                          (= :none (:optimizations options :none))
                          (not-empty watch-dirs))]
      (watch-build id paths build-inputs options cenv (config->reload-config config)))))

(defn log-server-start [repl-env]
  (let [host (get-in repl-env [:ring-server-options :host] "localhost")
        port (get-in repl-env [:ring-server-options :port] figwheel.repl/default-port)
        scheme (if (get-in repl-env [:ring-server-options :ssl?])
                 "https" "http")]
    (log/info (str "Starting Server at " scheme "://" host ":" port ))))

(defn start-file-logger []
  (when-let [log-fname (and (bound? #'*config*) (get-in *config* [::config :log-file]))]
    (log/info "Redirecting log ouput to file:" log-fname)
    (io/make-parents log-fname)
    (log/switch-to-file-handler! log-fname)))

;; ------------------------------
;; REPL
;; ------------------------------

(defn repl-api-docs []
  (let [dvars (filter (comp :cljs-repl-api meta) (vals (ns-publics 'figwheel.main)))]
    (string/join
     "\n"
     (map (fn [{:keys [ns name arglists doc]}]
            (str "--------------------------------------------------------------------------------\n"
             "(" ns "/" name
             (when-let [args (not-empty (first arglists))]
               (str " " (pr-str args)))
             ")\n   " doc))
          (map meta dvars)))))

#_(println (repl-api-docs))

(defn bound-var? [sym]
  (when-let [v (resolve sym)]
    (thread-bound? v)))

(defn in-nrepl? []
  (or
   (bound-var? 'nrepl.middleware.interruptible-eval/*msg*)
   (bound-var? 'clojure.tools.nrepl.middleware.interruptible-eval/*msg*)))

(defn nrepl-repl [repl-env repl-options]
  (if-let [piggie-repl (or (and (bound-var? 'cider.piggieback/*cljs-repl-env*)
                                (resolve 'cider.piggieback/cljs-repl))
                           (and (bound-var? 'cemerick.piggieback/*cljs-repl-env*)
                                (resolve 'cemerick.piggieback/cljs-repl)))]
    (apply piggie-repl repl-env (mapcat identity repl-options))
    (throw (ex-info "Failed to launch Figwheel CLJS REPL: nREPL connection found but unable to load piggieback.
This is commonly caused by
 A) not providing piggieback as a dependency and/or
 B) not adding piggieback middleware into your nrepl middleware chain.
Please see the documentation for piggieback here https://github.com/clojure-emacs/piggieback#installation

Note: Cider will inject this config into your project.clj.
This can cause confusion when your are not using Cider."
                    {::error :no-cljs-nrepl-middleware}))))

(defn repl-caught [err repl-env repl-options]
  (let [root-source-info (some-> err ex-data :root-source-info)]
    (if (and (instance? clojure.lang.IExceptionInfo err)
             (#{:js-eval-error :js-eval-exception} (:type (ex-data err))))
      (try
        (cljs.repl/repl-caught err repl-env repl-options)
        (catch Throwable e
          (let [{:keys [value stacktrace] :as data} (ex-data err)]
            (when value
              (println value))
            (when stacktrace
              (println stacktrace))
            (log/debug (with-out-str (pprint data))))))
      (let [except-data (fig-ex/add-excerpt (fig-ex/parse-exception err))]
        ;; TODO strange ANSI color error when printing this inside rebel-readline
        (println (binding [ansip/*use-color* (if (resolve 'rebel-readline.cljs.repl/repl*)
                                               false
                                               ansip/*use-color*)]
                   (ansip/format-str (log/format-ex except-data))))
        (log/debug (with-out-str (clojure.pprint/pprint (Throwable->map err))))
        (flush)))))

(def repl-header
  (str "Figwheel Main Controls:
          (figwheel.main/stop-builds id ...)  ;; stops Figwheel autobuilder for ids
          (figwheel.main/start-builds id ...) ;; starts autobuilder focused on ids
          (figwheel.main/reset)               ;; stops, cleans, reloads config, and starts autobuilder
          (figwheel.main/build-once id ...)   ;; builds source one time
          (figwheel.main/clean id ...)        ;; deletes compiled cljs target files
          (figwheel.main/status)              ;; displays current state of system
Figwheel REPL Controls:
          (figwheel.repl/conns)               ;; displays the current connections
          (figwheel.repl/focus session-name)  ;; choose which session name to focus on
In the cljs.user ns, controls can be called without ns ie. (conns) instead of (figwheel.repl/conns)
    Docs: (doc function-name-here)
    Exit: :cljs/quit
 Results: Stored in vars *1, *2, *3, *e holds last exception object"))

(defn repl [repl-env repl-options]
  (binding [cljs.analyzer/*cljs-warning-handlers*
            (conj (remove #{cljs.analyzer/default-warning-handler}
                          cljs.analyzer/*cljs-warning-handlers*)
                  (fn [warning-type env extra]
                    (when (get cljs.analyzer/*cljs-warnings* warning-type)
                      ;; warnings happen during compile so we must
                      ;; output to *err* but when rebel readline is
                      ;; available we will use the the root value of
                      ;; out which is bound to a special printer this
                      ;; is a bit tricky, its best just to handle
                      ;; *err* correctly in rebel-readline
                      (binding [*out*
                                (if (some-> (resolve 'rebel-readline.jline-api/*line-reader*)
                                            deref)
                                  (.getRawRoot #'*out*)
                                  *err*)]
                        (->> {:warning-type warning-type
                              :env env
                              :extra extra
                              :path ana/*cljs-file*}
                             figwheel.core/warning-info
                             (fig-ex/root-source->file-excerpt (:root-source-info env))
                             log/format-ex
                             ansip/format-str
                             string/trim-newline
                             println)
                        (flush)))))]
    (let [repl-options (-> repl-options
                           (assoc :caught (:caught repl-options repl-caught)))]
      (println (ansip/format-str
                [:bright (format "Prompt will show when REPL connects to evaluation environment (i.e. %s)"
                                 (if (= :nodejs (:target repl-options))
                                   "Node"
                                   "a REPL hosting webpage"))]))
      (println repl-header)

      (if (in-nrepl?)
        (nrepl-repl repl-env repl-options)
        (let [repl-fn (or (when-not (false? (:rebel-readline (::config *config*)))
                            (fw-util/require-resolve-var 'rebel-readline.cljs.repl/repl*))
                          cljs.repl/repl*)]
          (try
            (repl-fn repl-env repl-options)
            (catch clojure.lang.ExceptionInfo e
              (if (-> e ex-data :type (= :rebel-readline.jline-api/bad-terminal))
                (do (println (.getMessage e))
                    (cljs.repl/repl* repl-env repl-options))
                (throw e)))))))))

(defn repl-action [repl-env repl-options]
  (log-server-start repl-env)
  (log/info "Starting REPL")
  ;; when we have a logging file start log here
  (start-file-logger)
  (repl repl-env repl-options))

(defn serve [{:keys [repl-env repl-options eval-str join?]}]
  (cljs.repl/-setup repl-env repl-options)
  (when eval-str
    (cljs.repl/evaluate-form repl-env
                             (assoc (ana/empty-env)
                                    :ns (ana/get-namespace ana/*cljs-ns*))
                             "<cljs repl>"
                             ;; todo allow opts to be added here
                             (first (ana-api/forms-seq (StringReader. eval-str)))))
  (when-let [server (and join? @(:server repl-env))]
    (.join server)))

(defn serve-action [{:keys [repl-env] :as options}]
  (log-server-start repl-env)
  (start-file-logger)
  (serve options))

(defonce build-registry (atom {}))

(defn register-build! [id build-info]
  (swap! build-registry assoc id (assoc build-info :id id)))

(defn background-build [cfg {:keys [id config options]}]
  (let [{:keys [::build ::config repl-env-options repl-options] :as cfg}
        (-> (select-keys cfg [::start-figwheel-options])
            (assoc :options options
                   ::build {:id id :config (assoc config :mode :serve)})
            update-config)
        repl-env (figwheel.repl/repl-env*
                  (merge
                   repl-env-options
                   (select-keys cljs.repl/*repl-env* [:server])))
        cenv (cljs.env/default-compiler-env)
        repl-options (assoc repl-options :compiler-env cenv)
        build-inputs (::build-inputs config)]
    (when (empty? (:watch-dirs config))
          (log/failure (format "Can not watch build \"%s\" with no :watch-dirs" id)))
    (when (not-empty (:watch-dirs config))
      (log/info "Starting background autobuild - " (:id build))
      (binding [*config* cfg
                cljs.env/*compiler* cenv]
        (build-cljs (:id build) (apply bapi/inputs build-inputs) (:options cfg) cenv)
        (watch-build (:id build)
                     (:watch-dirs config)
                     build-inputs
                     (:options cfg)
                     cenv
                     (config->reload-config config))
        (register-build!
         (get-in *config* [::build :id])
         {:repl-env repl-env
          :repl-options repl-options
          :config *config*
          :background true})

        (when (first (filter #{'figwheel.core} (:preloads (:options cfg))))
          ;; let's take parent repl-env and change the connection filter
          (binding [cljs.repl/*repl-env* repl-env
                    figwheel.core/*config*
                    (select-keys config [:hot-reload-cljs
                                         :broadcast-reload
                                         :reload-dependents])]
            (doseq [init-fn (::initializers cfg)] (init-fn))))))))

(defn start-background-builds [{:keys [::background-builds] :as cfg}]
  (doseq [build background-builds]
    (background-build cfg build)))

(defn validate-fix-target-classpath! [{:keys [::config ::build options]}]
  (when (and (nil? (:target options))
             ;; if build-once and not :serve -> don't validate fix classpath
             (not (and (::build-once config)
                       (not (= (:mode config) :serve)))))
    ;; browsers need the target classpath to load files
    (when-not (contains? (:ring-stack-options config) :static)
      (when-let [output-to (:output-dir options (:output-to options))]
        (when-not (.isAbsolute (io/file output-to))
          (let [parts (fw-util/path-parts output-to)
                target-dir (first (split-with (complement #{"public"}) parts))]
            (when (some #{"public"} parts)
              (when-not (empty? target-dir)
                (let [target-dir (apply io/file target-dir)]
                  (if (and (fw-util/dir-on-classpath? target-dir)
                           (not (.exists target-dir)))
                    (if (get config :helpful-classpaths true)
                      (do
                        (log/warn
                         (ansip/format-str
                          [:yellow
                           "Making target directory "
                           (pr-str (str target-dir))
                           " and re-adding it to the classpath"
                           " (this only needs to be done when the target directory doesn't exist)"]))
                        (.mkdirs target-dir)
                        (fw-util/add-classpath! (.toURL target-dir)))
                      (log/warn (ansip/format-str
                                 [:yellow
                                  "Target directory "
                                  (pr-str (str target-dir))
                                  " is on the classpath but doesn't exist. The figwheel "
                                  "server will not be able to find compiled assets."])))
                    ;; quietly fix this situation??

                    (when-not (fw-util/dir-on-classpath? target-dir)
                      (if (get config :helpful-classpaths true)
                        (do
                          (.mkdirs target-dir)
                          (add-classpath! target-dir)
                          (warn-that-dir-not-on-classpath :target target-dir))
                        (log/warn (ansip/format-str
                                   [:yellow
                                    "Target directory "
                                    (pr-str (str target-dir))
                                    " is not on the classpath! The figwheel "
                                    "server will not be able to find compiled assets."]))))))))))))))

;; build-id situations
;; - temp-dir build id doesn't matter
;; - target directory build id
;;   (if unique would ensure clean main compile and run)
;;   when don't you want it to be unique
;;   when do you not want a clean compile when running main or repl?
;;     (when you are running it over and over again)
;;     for main we can use the main-ns for a build id
;;   - repl only
;;   - main only

(defn default-main [repl-env-fn cfg]
  (let [cfg (if (should-add-temp-dir? cfg)
              (add-temp-dir cfg)
              cfg)
        cfg (if (get-in cfg [::build :id])
              cfg
              (assoc-in cfg [::build :id] "figwheel-main-option-build"))
        output-to (get-in cfg [:options :output-to]
                          (default-output-to cfg))
        main (:main cfg)
        cfg (-> cfg
                (assoc-in [:options :aot-cache] false)
                (update :options #(assoc % :main
                                         (or (some-> (:main cfg) symbol)
                                             'figwheel.repl.preload)))
                (assoc-in [::config
                           :ring-stack-options
                           :figwheel.server.ring/dev
                           :figwheel.server.ring/system-app-handler]
                          ;; executing a function is slightly different as well
                          #(helper/middleware
                            %
                            {:header "Main fn exec page"
                             :body (str
                                    (format "<blockquote class=\"action-box\">Invoked main function: <code>%s/-main</code></blockquote>" (str main))
                                    (slurp
                                     (io/resource "public/com/bhauman/figwheel/helper/content/welcome_main_exec.html")))
                             :output-to output-to}))
                (assoc-in [::config :mode] :repl))
        source (:uri (fw-util/ns->location (get-in cfg [:options :main])))]
    (let [{:keys [options repl-options repl-env-options ::config] :as b-cfg}
          (update-config cfg)
          {:keys [pprint-config]} config]
      (validate-fix-target-classpath! b-cfg)
      (if pprint-config
        (do
          (log/info ":pprint-config true - printing config:")
          (print-conf b-cfg))
        (cljs.env/ensure
         (build-cljs (get-in b-cfg [::build :id] "figwheel-main-option-build")
                     source
                     (:options b-cfg) cljs.env/*compiler*)
         ;; all the complexity below is to handle async results from -main
         (let [stolen-repl-env (promise)
               result-prom (promise)]
           (async-result/listen result-prom)
           (try 
             (with-redefs [cljs.repl/tear-down (partial deliver stolen-repl-env)]
               (let [res (cljs.cli/default-main repl-env-fn b-cfg)
                     parsed-result (try
                                     (read-string res)
                                     (catch Throwable t
                                       ::read-error))]
                 (if (= parsed-result ::read-error)
                   (deliver result-prom res)
                   (if (and (coll? parsed-result)
                            (= (first parsed-result) :figwheel.main.async-result/wait))
                     (let [[_ arg1 arg2] parsed-result
                           timeout-val (or arg2 :figwheel.main.async-result/timed-out)]
                       (when (= timeout-val (deref result-prom (or arg1 5000) timeout-val))
                         (println (pr-str timeout-val))
                         (throw (ex-info "Main script timed out" {:value timeout-val}))))
                     (deliver result-prom parsed-result)))
                 (let [final-result @result-prom]
                   (if (and (map? final-result)
                            (= (get final-result :type)
                               :figwheel.main.async-result/exception))
                     (throw (ex-info
                             (:value final-result "System error exit from ClojureScript")
                             {:type :js-eval-exception
                              :error final-result
                              :repl-env @stolen-repl-env}))
                     (if (string? final-result)
                       (println final-result)
                       (println (pr-str final-result)))))))
             (finally
               (cljs.repl/tear-down @stolen-repl-env)))))))))

(defn add-default-system-app-handler [{:keys [options ::config] :as cfg}]
  (let [extra-mains-name->output-to
        (into {}
              (keep (fn [[nm em-options]]
                      [(name nm) (:output-to (extra-main-options nm em-options options))])
                    (:extra-main-files config)))]
    (update-in
     cfg
     [:repl-env-options
      :ring-stack-options
      :figwheel.server.ring/dev
      :figwheel.server.ring/system-app-handler]
     (fn [sah]
       (if sah
         sah
         #(-> %
           (helper/extra-main-hosting extra-mains-name->output-to)
           (helper/missing-index
            (if (and (:modules options)
                     (:output-dir options))
              {:output-to (str (io/file (:output-dir options) "cljs_base.js"))}
              (select-keys (:options cfg) [:output-to])))))))))

(defn validate-basic-assumptions! [{:keys [options ::config] :as cfg}]
  (when (and (= (:mode config) :repl)
             (not= :none (:optimizations options :none)))
    (throw (ex-info "Can only start a REPL and inject hot-reloading when the :optimizations level is set to :none" {::error true}))))

(defn default-compile [repl-env-fn cfg]
  (let [{:keys [options repl-options repl-env-options ::config] :as b-cfg}
        (add-default-system-app-handler (update-config cfg))
        {:keys [mode pprint-config ::build-once]} config
        repl-env (apply repl-env-fn (mapcat identity repl-env-options))
        cenv (cljs.env/default-compiler-env options)
        repl-options (assoc repl-options :compiler-env cenv)]
    (validate-basic-assumptions! b-cfg)
    (validate-fix-target-classpath! b-cfg)
    (binding [*base-config* cfg
              *config* b-cfg]
      (cljs.env/with-compiler-env cenv
        (log/trace "Verbose config:" (with-out-str (pprint b-cfg)))
        (if pprint-config
          (do
            (log/info ":pprint-config true - printing config:")
            (print-conf b-cfg))
          (binding [cljs.repl/*repl-env* repl-env
                    figwheel.core/*config* (select-keys config [:hot-reload-cljs
                                                                :broadcast-reload
                                                                :reload-dependents])]
            (try
              (let [fw-mode? (figwheel-mode? b-cfg)]
                (try
                  (build config options cenv)
                  (catch Throwable t
                    (log/error t)))
                (log/trace "Figwheel.core config:" (pr-str figwheel.core/*config*))
                (when-not build-once
                  (register-build!
                   (get-in *config* [::build :id])
                   {:repl-env repl-env
                    :repl-options repl-options
                    :config *config*})
                  (start-background-builds (select-keys cfg [::background-builds
                                                             ::start-figwheel-options]))
                  (doseq [init-fn (::initializers b-cfg)] (init-fn)))
                (cond
                  (and (= mode :repl) (not build-once))
                  ;; this forwards command line args
                  (repl-action repl-env repl-options)
                  (= mode :serve)
                  ;; we need to get the server host:port args
                  (serve-action
                   {:repl-env repl-env
                    :repl-options repl-options
                    :join? (get b-cfg ::join-server? true)})
                  ;; the final case is compiling without a repl or a server
                  ;; if there is a watcher running join it
                  (and (not build-once)
                       (fww/running?)
                       (get b-cfg ::join-server? true))
                  (fww/join)))
              (finally
                ;; these are the blocking states that we want to clean up after
                (when (or (get b-cfg ::join-server? true)
                          (and
                           (not (in-nrepl?))
                           (= mode :repl)))
                  (fww/stop!)
                  (remove-watch cenv :figwheel.core/watch-hook)
                  (swap! build-registry dissoc (get-in *config* [::build :id])))))))))))

;; ------------------------------------------------------------
;; REPL API
;; ------------------------------------------------------------

(defn- start-build-arg->build-options [build]
  (let [[build-id build-options config]
        (if (map? build)
          [(:id build) (:options build)
           (:config build)]
          [build])
        build-id (name build-id)
        options  (or (and (not build-options)
                          (get-build build-id))
                     build-options
                     {})
        config  (or config (meta options))]
    (cond-> {:id build-id
             :options options}
      config (assoc :config config))))

(defn build-option-arg? [a]
  (or
   (string? a)
   (keyword? a)
   (symbol? a)
   (and (map? a)
        (:id a)
        (:options a))))

(defn start*
  ([join-server? build]
   (assert (build-option-arg? build) "Figwheel Start: build argument required")
   (start* join-server? nil build))
  ([join-server? figwheel-options-or-build bbuild & builds]
   (let [[figwheel-options build & background-builds]
         (if-not (build-option-arg? figwheel-options-or-build)
           (concat [figwheel-options-or-build bbuild] builds)
           (concat [nil figwheel-options-or-build bbuild] builds))
         {:keys [id] :as build} (start-build-arg->build-options build)
         cfg
         (cond-> {:options (:options build)
                  ::join-server? (if (true? join-server?) true false)}
           figwheel-options (assoc ::start-figwheel-options figwheel-options)
           id    (assoc ::build (dissoc build :options))
           (and (not (get figwheel-options :mode))
                (= :none (get-in build [:options :optimizations] :none)))
           (assoc-in [::config :mode] :repl)
           (not-empty background-builds)
           (assoc ::background-builds (mapv
                                       start-build-arg->build-options
                                       background-builds)))]
     (if (and id (get @build-registry id))
       (throw (ex-info (format "A build with id \"%s\" is already running." id) {}))
       (default-compile cljs.repl.figwheel/repl-env cfg)))))

(defn ^{:deprecated "0.1.6"} start
  "Starts a Figwheel build process.

   Deprecated see the documentation for figwheel.main.api/start"
  [& args]
  (apply start* false args))

(defn ^{:deprecated "0.1.6"} start-join
  "Deprecated see the documentation for figwheel.main.api/start-join"
  [& args]
  (apply start* true args))

;; ----------------------------------------------------------------------------
;; CLJS REPL api
;; ----------------------------------------------------------------------------

;; Unfortunately this is rather hacky way to allow some control over builds
;; this works fine for allowing folks to reset builds that are running
;; but not super helpful otherwise

;; this does not allow starting up new builds or truely dropping a
;; build it only manages stopping and starting the the watcher
;; process, reloading the config, and stopping the watcher process
;; it doesn't stop and restart the server as that would interrupt the repl
;; session

(defn autobuilding-ids []
  (->> (:watches @fww/*watcher*)
       keys
       (filter #(-> % first (= ::autobuild)))
       (map second)
       set))

(defn currently-available-ids [] (set (keys @build-registry)))

;; doesn't respect ::start-figwheel-options
(defn config-for-id [id]
  (when-let [{:keys [config]} (get @build-registry id)]
    config))

(defn clean-build [{:keys [output-to output-dir]}]
  (when (and output-to output-dir)
    (doseq [file (cons (io/file output-to)
                       (reverse (file-seq (io/file output-dir))))]
      (when (.exists file) (.delete file)))))

(defn warn-on-bad-id [ids]
  (when-let [bad-ids (not-empty (remove (currently-available-ids) ids))]
    (doseq [bad-id bad-ids]
      (println "No available build currently has id:" bad-id))))

;; TODO this should clean ids that are not currently running as well
;; TODO should this default to cleaning all builds??
;; I think yes
(defn clean* [ids]
  (let [ids (->> ids (map name) distinct)]
    (warn-on-bad-id ids)
    (doseq [id ids]
      (when-let [options (-> build-registry deref (get id) :config :options)]
        (println "Cleaning build id:" id)
        (clean-build options)))))

(defmacro ^:cljs-repl-api clean
  "Takes one or more builds ids and deletes their compiled artifacts."
  [& build-ids]
  (clean* (map name build-ids))
  nil)

(defn status* []
  (println "------- Figwheel Main Status -------")
  (println "Currently available:" (string/join ", " (currently-available-ids)))
  (if-let [ids (not-empty (autobuilding-ids))]
    (println "Currently building:" (string/join ", " ids))
    (println "No builds are currently being built.")))

(defmacro ^:cljs-repl-api status
  "Displays the build ids of the builds are currently being watched and compiled."
  []
  (status*) nil)

(defn stop-builds* [ids]
  (let [ids (->> ids (map name) distinct)]
    (warn-on-bad-id ids)
    (doseq [k (map #(vector ::autobuild %) ids)]
      (when (-> fww/*watcher* deref :watches (get k))
        (println "Stopped building id:" (last k))
        (fww/remove-watch! k)))))

;; TODO should this default to stopping all builds??
;; I think yes
(defmacro ^:cljs-repl-api stop-builds
  "Takes one or more build ids and stops watching and compiling them."
  [& build-ids]
  (stop-builds*
   (or (not-empty build-ids)
       (autobuilding-ids)))
  nil)

(defn start-build*
  "This starts a build that has previously been stopped."
  [id]
  (when-let [{:keys [repl-env repl-options] :as build-info} (get @build-registry (name id))]
    (let [{:keys [options ::config]} (:config build-info)
          {:keys [watch-dirs ::build-inputs]} config
          compiler-env (:compiler-env repl-options)]
      (println "Starting build id:" id)
      ;; XXX should this have syntax error feedback?
      (build-cljs id (apply bapi/inputs build-inputs) options compiler-env)
      (watch-build id
                   watch-dirs
                   build-inputs
                   options
                   compiler-env
                   (config->reload-config config))
      ;; this might not even need to be done
      #_(when (first (filter #{'figwheel.core} (:preloads options)))
        (binding [cljs.repl/*repl-env* repl-env]
          (figwheel.core/start*))))))

(defn start-builds* [ids]
  (let [ids (->> ids (map name) distinct)
        already-building (not-empty (filter (autobuilding-ids) ids))
        ids (filter (complement (autobuilding-ids)) ids)]
    (when (not-empty already-building)
      (doseq [i already-building]
        (println "Already building id: " i)))
    (doseq [id ids]
      (start-build* id))))

(defmacro ^:cljs-repl-api start-builds
  "Takes one or more build names and starts them building."
  [& build-ids]
  (start-builds*
   (or (not-empty build-ids)
       (currently-available-ids)))
  nil)

(defn reload-config* [id]
  (println "Reloading config for id:" id)
  ;; update the config in the registry
  (when-let [{:keys [build-info]} (get (currently-available-ids) (name id))]
    (swap! build-registry update-in [id :config]
           #(update-config
             (-> (when (::start-figwheel-options %)
                   (select-keys % ::start-figwheel-options))
                 (build-opt id)
                 (assoc-in [::config :mode] :repl))))))

(defn reset* [ids]
  (let [ids (->> ids (map name) distinct)
        ids (or (not-empty ids) (autobuilding-ids))]
    (clean* ids)
    (stop-builds* ids)
    (mapv reload-config* ids)
    (start-builds* ids)
    nil))

(defmacro ^:cljs-repl-api reset
  "If no args are provided, all current builds will be cleaned and restarted.
   Otherwise, this will clean and restart the provided build ids."
  [& build-ids]
  (reset* build-ids))

;; TODO build inputs will affect this
(defn build-once* [ids]
  (let [ids (->> ids (map name) distinct)
        bad-ids (filter (complement (currently-available-ids)) ids)
        good-ids (filter (currently-available-ids) ids)]
    (when (not-empty bad-ids)
      (doseq [i bad-ids]
        (println "Build id not found:" i)))
    (when (not-empty good-ids)
      ;; clean?
      (doseq [i good-ids]
        (let [{:keys [options ::config]} (config-for-id i)
              input (if-let [paths (not-empty (:watch-dirs config))]
                      (apply bapi/inputs paths)
                      (when-let [source (when (:main options)
                                          (:uri (fw-util/ns->location (symbol (:main options)))))]
                        source))]
          (when input
            (build-cljs i input options
                         (cljs.env/default-compiler-env options))))))))

(defmacro ^:cljs-repl-api build-once
  "Forces a single compile of the provided build ids."
  [& build-ids]
  (build-once* build-ids)
  nil)

;; ----------------------------------------------------------------------------
;; Main
;; ----------------------------------------------------------------------------

(defn fix-simple-bool-arg* [flags args]
  (let [[pre post] (split-with (complement flags) args)]
    (if (empty? post)
      pre
      (concat pre [(first post) "true"] (rest post)))))

(defn fix-simple-bool-args [flags args]
  (reverse
   (reduce (fn [accum arg]
             (if (and (flags (first accum))
                      (not (#{"true" "false"} arg)))
               (-> accum
                   (conj "true")
                   (conj arg))
               (conj accum arg)))
           (list)
           args)))

(defn -main [& orig-args]
  ;; todo make this local with-redefs?
  (alter-var-root #'cli/default-commands cli/add-commands figwheel-commands)
  ;; set log level early
  (when-let [level (get-edn-file-key "figwheel-main.edn" :log-level)]
    (log/set-level level))
  (try
    (let [args       (fix-simple-bool-args #{"-pc" "--print-config"} orig-args)
          [pre post] (split-with (complement #{"-re" "--repl-env"}) args)
          _          (when (not-empty post)
                       (throw
                        (ex-info (str "figwheel.main does not support the --repl-env option\n"
                                      "The figwheel REPL is implicitly used.\n"
                                      "Perhaps you were intending to use the --target option?")
                                 {::error true})))
          _          (validate-cli! (vec orig-args))
          args'      (concat ["-re" "figwheel"] args)
          args'      (if (or (empty? args)
                             (= args ["-pc" "true"])
                             (= args ["--print-config" "true"]))
                       (concat args' ["-r"]) args')]
      (with-redefs [cljs.cli/default-compile default-compile
                    cljs.cli/load-edn-opts load-edn-opts]
        (apply cljs.main/-main args')))
    (catch Throwable e
      (let [d (ex-data e)]
        (cond
          (or
           (:figwheel.main.schema.core/error d)
           (:figwheel.main.schema.cli/error d)
           (:cljs.main/error d)
           (::error d))
          (binding [*out* *err*]
            (println (.getMessage e)))
          (and (#{:js-eval-exception :js-eval-error} (:type d))
               (:error d))
          (let [{:keys [repl-env error form]} d]
            (#'cljs.repl/display-error repl-env error form {})
            (throw e))
          :else (throw e))))))

)
   )

#_(def test-args
  (concat ["-co" "{:aot-cache false :asset-path \"out\"}" "-b" "dev" "-e" "(figwheel.core/start-from-repl)"]
          (string/split "-w src -d target/public/out -o target/public/out/mainer.js -c exproj.core -r" #"\s")))

#_(handle-build-opt (concat (first (split-at-main-opt args)) ["-h"]))

#_(apply -main args)
#_(.stop @server)