(ns verita.util.metrics
  (:gen-class)
  (:require [clojure.spec.alpha :as spec]
            [io.pedestal.log :as logger]
            [mount.core :refer [defstate] :as mount]
            [environ.core :refer [env]]
            [verita.util.common :as common])
  (:import (java.util.concurrent TimeUnit)
           (org.slf4j LoggerFactory)
           (com.codahale.metrics Slf4jReporter Gauge MetricRegistry
                                 ConsoleReporter ScheduledReporter MetricFilter)
           (com.codahale.metrics.health HealthCheck)
           (com.readytalk.metrics StatsDReporter)))

;; enable asserts
(spec/check-asserts true)


(def ^:dynamic *config*
  {:reporter-type (-> env :verita-reporter keyword)
   :report-period (or (common/safe (Integer. ^String (:verita-report-period env))) 2)
   :statsd-server (or (:statsd-server env) "127.0.0.1")
   :statsd-port   (or (common/safe (Integer. ^String (:statsd-port env))) 8125)})

(spec/def ::registry #(instance? MetricRegistry %))
(spec/def ::time-unit #(instance? TimeUnit %))
(spec/def ::rate-unit ::time-unit)
(spec/def ::duration-unit ::time-unit)
(spec/def ::report-period pos-int?)
(spec/def ::report-timeunit ::time-unit)
(spec/def ::logger-name string?)
(spec/def ::prefix string?)
(spec/def ::reporter-type #{:console :slf4j :statsd})
(spec/def ::host string?)
(spec/def ::port pos-int?)
(spec/def ::max-size-bytes pos-int?)
(spec/def ::max-latency-ms pos-int?)


(defmulti reporter-type ::reporter-type)


(defmethod reporter-type :console [_]
  (spec/keys :req [::registry
                   ::rate-unit
                   ::duration-unit
                   ::report-period
                   ::report-timeunit]))


(defmethod reporter-type :slf4j [_]
  (spec/keys :req [::registry
                   ::rate-unit
                   ::duration-unit
                   ::report-period
                   ::report-timeunit
                   ::logger-name]))


(defmethod reporter-type :statsd [_]
  (spec/keys :req [::registry
                   ::host
                   ::port
                   ::rate-unit
                   ::duration-unit
                   ::report-period
                   ::report-timeunit]))


(spec/def ::reporter-params (spec/multi-spec reporter-type ::reporter-type))


(defn console-reporter
  "create console reporter for given registry and start it. return nil."
  [params]
  (spec/assert ::reporter-params params)
  (doto (some-> (ConsoleReporter/forRegistry (::registry params))
                (.outputTo System/out)
                (.convertRatesTo (::rate-unit params))
                (.convertDurationsTo (::duration-unit params))
                (.build))
    (.start (::report-period params) (::report-timeunit params))))


(defn slf4j-reporter
  "create SLF4j reporter for given registry and start it. return nil."
  [params]
  (spec/assert ::reporter-params params)
  (doto (some-> (Slf4jReporter/forRegistry (::registry params))
                (.outputTo (LoggerFactory/getLogger ^String (::logger-name params)))
                (.convertRatesTo (::rate-unit params))
                (.convertDurationsTo (::duration-unit params))
                (.build))
    (.start (::report-period params) (::report-timeunit params))))

(defn statsd-reporter
  "create StatsD reporter for given registry and start it. return nil."
  [params]
  (spec/assert ::reporter-params params)
  (doto (some-> (StatsDReporter/forRegistry (::registry params))
                (.convertRatesTo (::rate-unit params))
                (.convertDurationsTo (::duration-unit params))
                (.build (::host params) (::port params)))
    (.start (::report-period params) (::report-timeunit params))))


(defn init-metric-reporter
  "return initialzed MetricRegistry object."
  [reporter-type]

  (case (spec/assert ::reporter-type reporter-type)

    :console (logger/metric-registry #(console-reporter {::reporter-type   :console
                                                         ::registry        %
                                                         ::rate-unit       TimeUnit/SECONDS
                                                         ::duration-unit   TimeUnit/MILLISECONDS
                                                         ::report-period   (:report-period *config*)
                                                         ::report-timeunit TimeUnit/SECONDS}))

    :slf4j (logger/metric-registry #(slf4j-reporter {::reporter-type   :slf4j
                                                     ::registry        %
                                                     ::rate-unit       TimeUnit/SECONDS
                                                     ::duration-unit   TimeUnit/MILLISECONDS
                                                     ::report-period   (:report-period *config*)
                                                     ::report-timeunit TimeUnit/SECONDS
                                                     ::logger-name     "verita"}))

    :statsd (logger/metric-registry #(statsd-reporter {::reporter-type   :statsd
                                                       ::host            (:statsd-server *config*)
                                                       ::port            (Integer. (:statsd-port *config*))
                                                       ::registry        %
                                                       ::rate-unit       TimeUnit/SECONDS
                                                       ::duration-unit   TimeUnit/MILLISECONDS
                                                       ::report-period   (:report-period *config*)
                                                       ::report-timeunit TimeUnit/SECONDS}))))




;; Defines reporter to be passed to metrics functions
(defonce custom-reporter (init-metric-reporter (:reporter-type *config*)))

(logger/gauge custom-reporter "verita.jvm.max" (fn [] (common/max-jvm-memory)))
(logger/gauge custom-reporter "verita.jvm.free" (fn [] (common/free-jvm-memory)))
(logger/gauge custom-reporter "verita.jvm.total" (fn [] (common/total-jvm-memory)))
(logger/gauge custom-reporter "verita.jvm.used" (fn [] (common/used-jvm-memory)))

(logger/gauge custom-reporter "verita.cpu.system" (fn [] (common/system-cpu-load)))
(logger/gauge custom-reporter "verita.cpu.jvm-proc" (fn [] (common/process-cpu-load)))

(logger/gauge custom-reporter "verita.file.max-descr" (fn [] (common/max-file-descriptor)))
(logger/gauge custom-reporter "verita.file.open-descr" (fn [] (common/open-file-descriptor)))

(logger/gauge custom-reporter "verita.swap.total" (fn [] (common/total-swap-size)))
(logger/gauge custom-reporter "verita.swap.free" (fn [] (common/free-swap-size)))