(defn all-files
  ([] (all-files ["."]))
  ([paths] (all-files paths {}))
  ([paths opts]
   (all-files paths opts (project)))
  ([paths opts project]
   (let [filt (-> {:include *include*}
                  (merge opts)
                  (update-in [:exclude]
                             conj
                             fs/link?))
         result (->> paths
                     (map #(fs/path (:root project) %))
                     (mapcat #(fs/select % filt))
                     (map str)
                     (map (juxt file-namespace identity))
                     (into {}))]
     (dissoc result nil))))

(defn exclude
  [lookup exclusions]
  (reduce-kv (fn [out ns v]
               (let [nss (str ns)
                     exclude? (->> exclusions
                                   (map (fn [ex]
                                          (.startsWith nss ex)))
                                   (some true?))]
                 (if exclude?
                   out
                   (assoc out ns v))))
             {}

             lookup))

(defn file-lookup
  ([] (file-lookup (project)))
  ([project]
   (all-files (concat (:source-paths project)
                      (:test-paths project))
              {}
              project)))

(defn file-namespace
  [path]
  (try
    (->> (fs/read-code path)
         (filter #(-> % first (= 'ns)))
         first
         second)
    (catch Throwable t
      (println path "Cannot be loaded"))))

(defn file-suffix
  ([] (file-suffix common/*type*))
  ([type]
   (-> (common/type-lookup type) :extension)))

(defn file-type
  [path]
  (cond (.endsWith (str path)
                   (str (munge (test-suffix))
                        (file-suffix)))
        :test

        :else
        :source))

(defmacro in-context
  [[func & args]]
  (let [project `(project)
        lookup  `(all-files ["src" "test"] {} ~'project)
        current `(.getName *ns*)
        params  `{}]
    (case (count args)
      0  `(let [~'project ~project]
            (~func ~current ~params ~lookup ~'project))
      1   (if (map? (first args))
            `(let [~'project ~project]
               (~func ~current ~(first args) ~lookup ~'project))
            `(let [~'project ~project]
               (~func ~(first args) ~params ~lookup ~'project)))
      2   `(let [~'project ~project]
             (~func ~@args ~lookup ~'project)))))

(defn project
  ([] (project (project-file)))
  ([path]
   (cond (nil? path)
         (throw (ex-info "Cannot find project" {:path nil}))
         
         (fs/input-stream? path)
         (lein/project path)
         
         :else
         (project-fn path (-> (fs/path path)
                              (fs/attributes)
                              (:last-modified-time))))))

(defn project-file
  []
  (->> [lein/*project-file*
        shadow/*shadow-file*]
       (filter fs/exists?)
       (first)))

(defn project-name
  ([] (:name (project)))
  ([path]
   (:name (project path))))

(defn source-ns
  [ns]
  (let [sns (str (sym-name ns))
        suffix (test-suffix)
        sns (if (.endsWith (str sns) suffix)
              (subs sns 0 (- (count sns) (count suffix)))
              sns)]
    (symbol sns)))

(defn sym-name
  [x]
  (cond (instance? clojure.lang.Namespace x)
        (.getName x)

        (symbol? x)
        x

        :else
        (throw (ex-info "Only symbols and namespaces are supported" {:type (type x)
                                                                     :value x}))))

(defn test-ns
  [ns]
  (let [sns (str (sym-name ns))
        suffix (test-suffix)
        sns (if (.endsWith (str sns) suffix)
              sns
              (str sns suffix))]
    (symbol sns)))

(defn test-suffix
  ([] common/*test-suffix*)
  ([s] (alter-var-root #'common/*test-suffix*
                       (constantly s))))