;; copy a download method from git hub
 
 
(defn pretty-file-size
  "Takes number of bytes and returns a prettied string with an appropriate unit:
  b, kb or mb."
  [n-bytes]
  (let [n-kb (int (/ n-bytes 1024))
        n-mb (int (/ n-kb 1024))]
    (cond
     (< n-bytes 1024) (str n-bytes " B")
     (< n-kb 1024)    (str n-kb " KB")
     :else            (str n-mb " MB"))))
 
 
(defn print-file-copy-status
  "Print copy status in percentage - granularity times - evenly as
  num-copied-bytes approaches file-size"
  [num-copied-bytes buf-size file-size slices]
  (let [min    num-copied-bytes
        max    (+ buf-size num-copied-bytes)]
    (when-let [slice (some (fn [slice]
                             (when (and (> (:val slice) min)
                                        (< (:val slice) max))
                               slice))
                           slices)]
      (println (str (:perc slice) "% (" (pretty-file-size num-copied-bytes)  ") completed")))))
 
(defn percentage-slices
  "Returns a seq of maps of length num-slices where each map represents the
  percentage and the associated percentage of size
  usage:
  (percentage-slices 1000 2) ;=> ({:perc 50N, :val 500N} {:perc 100, :val 1000})"
  [size num-slices]
  (map (fn [slice]
         (let [perc (/ (inc slice) num-slices)]
           {:perc (* 100 perc)
            :val  (* size perc)}))
       (range num-slices)))
 
 
(defn remote-file-copy [in-stream out-stream]
  "Similar to  the corresponding implementation of #'do-copy in 'clojure.java.io
  but also tracks how many bytes have been downloaded and prints percentage
  statements when *verbose-overtone-file-helpers* is bound to true."
  (let [buf-size 2048
        buffer   (make-array Byte/TYPE buf-size)]
    (loop [bytes-copied 0]
      (let [size (.read in-stream buffer)]
        (when (pos? size)
          (do (.write out-stream buffer 0 size)
              (recur (+ size bytes-copied))))))
    (println "--> Download successful")))
 
 
(defn download-file-with-timeout
  "Downloads remote file at url to local file specified by target path. If data
  transfer stalls for more than timeout ms, throws a
  java.net.SocketTimeoutException"
  [url target-path timeout]
  (let [
        url         (java.net.URL. url)
        con         (.openConnection url)]
    (.setReadTimeout con timeout)
    (with-open [in (.getInputStream con)
                out (clojure.java.io/output-stream target-path)]
      (remote-file-copy in out))
    target-path))
 
;(download-file-with-timeout "http://zhangley.com/images/2016-04-19_9-10-15.jpg" "c:\\tmp\\aa.jpg" (* 5 60 1000)) ; 一般的文件5分钟足够了
 
 
(defn download-file*
  ([url path timeout]                  (download-file-with-timeout url path timeout))
  ([url path timeout n-retries]        (download-file* url path timeout n-retries 5000))
  ([url path timeout n-retries wait-t] (download-file* url path timeout n-retries wait-t 0))
  ([url path timeout n-retries wait-t attempts-made]
     (when (>= attempts-made n-retries)
       (throw (Exception. (str "Aborting! Download failed after "
                               n-retries
                               " attempts. URL attempted to download: "
                               url ))))
 
     (let [path path]
       (try
         (download-file-with-timeout url path timeout)
         (catch Exception e
           (Thread/sleep wait-t)
           (println (str "Download timed out. Retry " (inc attempts-made) ": " url ))
           (download-file* url path timeout n-retries wait-t (inc attempts-made)))))))
 
 
(defn download-file
  "Downloads the file pointed to by url to local path. If no timeout
  is specified will use blocking io to transfer data. If timeout is specified,
  transfer will block for at most timeout ms before throwing a
  java.net.SocketTimeoutException if data transfer has stalled.
  It's also possible to specify n-retries to determine how many attempts to
  make to download the file and also the wait-t between attempts in ms (defaults
  to 5000 ms)
  Verbose mode is enabled by binding *verbose-overtone-file-helpers* to true."
  ([url path timeout]
     (download-file* url path timeout))
  ([url path timeout n-retries]
 
     (download-file* url path timeout n-retries))
  ([url path timeout n-retries wait-t]
 
     (download-file* url path timeout n-retries wait-t)))