std.lib.network

(defn- ip-score
  [^String ip]
  (cond (clojure.string/starts-with? ip "192.168.") 0
        (clojure.string/starts-with? ip "10.")      1
        (and (clojure.string/starts-with? ip "172.")
             (let [n (try (Integer/parseInt (second (clojure.string/split ip #"\.") 0))
                          (catch Throwable _ 0))]
               (<= 16 n 31)))                        2
        :else                                        3))

(defn ^java.net.Inet4Address local-host
  ([]
   (java.net.InetAddress/getLocalHost)))

(defn local-hostname
  ([]
   (.getHostName (local-host))))

(defn local-ip
  ([]
   (.getHostAddress (local-host))))

(defn local-ip-lan
  []
  (->> (NetworkInterface/getNetworkInterfaces)
       (enumeration-seq)
       (filter (fn [^NetworkInterface ni]
                 (and (.isUp ni)
                      (not (.isLoopback ni))
                      (not (.isPointToPoint ni)))))
       (mapcat (fn [^NetworkInterface ni]
                 (enumeration-seq (.getInetAddresses ni))))
       (filter (fn [^InetAddress addr]
                 (and (instance? java.net.Inet4Address addr)
                      (not (.isLoopbackAddress addr))
                      (not (.isLinkLocalAddress addr)))))
       (map #(.getHostAddress ^InetAddress %))
       (sort-by ip-score)
       first))

(defn local-shortname
  ([]
   (-> (local-hostname)
       (clojure.string/split #"\.")
       first)))

(defn port:check-available
  ([port]
   (try
     (with-open [^ServerSocket s (ServerSocket. port)]
       (.setReuseAddress s true)
       (.getLocalPort s))
     (catch Throwable t
       false))))

(defn port:get-available
  ([ports]
   (reduce (fn [_ i]
             (if (port:check-available i) (reduced i)))
           nil ports)))

(defn ^Socket socket
  ([^long port]
   (socket nil port))
  ([^String host ^long port]
   (Socket. (or host "localhost") port)))

(defn socket:address
  ([^Socket socket]
   (str (.getInetAddress socket))))

(defn socket:local-address
  ([^Socket socket]
   (str (.getLocalAddress socket))))

(defn socket:local-port
  ([^Socket socket]
   (.getLocalPort socket)))

(defn socket:port
  ([^Socket socket]
   (.getPort socket)))

(defn wait-for-port
  ([host port]
   (wait-for-port host port {}))
  ([host port {:keys [timeout pause] :as opts}]
   (let [t0 (time/time-ms)]
     (loop [retries 0]
       (let [[retry? timeout?]
             (try (env/close (socket host port))
                  [false false]
                  (catch ConnectException _
                    (if (or (nil? timeout)
                            (< (time/elapsed-ms t0) timeout))
                      [true false]
                      [false true])))]
         (cond retry?
               (do (Thread/sleep (long (or pause 100)))
                   (recur (inc retries)))

               :else
               (let [data {:host host
                           :port port
                           :elapsed (time/elapsed-ms t0)
                           :retries retries}]
                 (if timeout?
                   (throw (ex-info "Timed out" data))
                   data))))))))