(ns ufc

  (:require 

   [gorilla-plot.core :as plot]

   [gorilla-renderable.core :as r]

   [gorilla-repl.html :as h]

   [clojure.pprint :refer [pprint

                           print-table]]

   [clojure.data.json :as json]

    [clojure.string :as s]

   [hiccup.core :refer [html]]))

​

;; Define the default dataset file

​

(def stats-json-fp "complete-fighter-stats.json")

​

;; Define the default JSON key

​

(def entry-point

  "Default JSON key for main data"

  "fighters")

​

;; Function gets the JSON value of entry-point

​

(defn stats*

  "Loads JSON file and returns entry-point value."

  ([fp] (stats* fp entry-point))

  ([fp entry-point]

     (-> fp

         slurp

         json/read-str

         (get entry-point {}))))

​

;; Create a version of stats* that caches the results

​

(let [f (memoize stats*)]

  (defn stats

  "Loads JSON file and returns cached entry-point value."

  ([]

     (f stats-json-fp))

  ([^:String fp] 

     (f fp entry-point))

  ([^:String fp 

    ^:String entry-point]

     (f fp entry-point))))

​

;; Bruteforce numeric type enforcement

​

(defn enforce-type

  "Integer first, Float second, original object on fail"

  [x]

  (try

    (Integer/parseInt x)

    (catch Exception ex

      (try

        (Float/parseFloat x)

        (catch Exception ex x)))))

​

;; The function used to modify fighter-without-fights fn

​

(defn recursive-enforce-type

  "recursively calls enforce-type on a fighter map"

  [x]

  (reduce merge

          (for [[k v] x

                :let [f (if-not (map? v)

                          enforce-type

                          recursive-enforce-type)]]

            (hash-map k (f v)))))

​

;; Add recursive-enforce-type to this fn

​

(defn fighter-without-fights

  "Returns a fighter without fights collection"

  [fighter-map]

  (recursive-enforce-type

   (dissoc fighter-map "Fights")))

​

(defn ->numerics

  "Recursively filters for numeric values from a fighter map"

  [x]

  (let [data (recursive-enforce-type x)]

    (reduce merge

            (for [[k v] data]

              (if-not (map? v)

                (if-not (number? v)

                  {}

                  (hash-map k v))

                (->numerics v))))))

​

(defn without

  "Removes values from a fighter map"

  [x & ks]

  (apply dissoc x ks))

​

(defn ->numeric-map

  "Returns numeric map without IDs"

  [x]

  (-> x

      fighter-without-fights

      ->numerics

      (without "MMAID"

               "WeightClassID"

               "FighterID")))

​

(defn ->html [x]

  (h/html-view (html x)))

(defn x-gen-get-it [get-in-coll]

  (map #(-> %

            (get-in get-in-coll 0)

            enforce-type)))

​

(def x-age

  (x-gen-get-it ["Age"]))

​

(def x-previous

  (x-gen-get-it ["Previous"]))

​

(def x-current

  (x-gen-get-it ["Current"]))

​

(def x-striking-defense

  (x-gen-get-it ["StrikingDefense"]))

​

(def x-no-contests

  (x-gen-get-it ["NoContests"]))

​

(def x-takedown-defense

  (x-gen-get-it ["TakedownDefense"]))

​

(def x-kd-average

  (x-gen-get-it ["KDAverage"]))

​

(def x-takedown-average

  (x-gen-get-it ["TakedownAverage"]))

​

(def x-weight

  (x-gen-get-it ["Weight"]))

​

(def x-wins

  (x-gen-get-it ["Wins"]))

​

(def x-draws

  (x-gen-get-it ["Draws"]))

​

(def x-reach

  (x-gen-get-it ["Reach"]))

​

(def x-height

  (x-gen-get-it ["Height"]))

​

(def x-takedown-accuracy

  (x-gen-get-it ["TakedownAccuracy"]))

​

(def x-slpm

  (x-gen-get-it ["SLpM"]))

​

(def x-submissions-average

  (x-gen-get-it ["SubmissionsAverage"]))

​

(def x-losses

  (x-gen-get-it ["Losses"]))

​

(def x-average-fight-time-seconds

  (x-gen-get-it ["AverageFightTime_Seconds"]))

​

(def x-striking-accuracy

  (x-gen-get-it ["StrikingAccuracy"]))

​

(def x-sapm

  (x-gen-get-it ["SApM"]))

​

(def x-numeric-map

  (map ->numeric-map))

​

;; Testing the above by using x-age and x-losses

;; on a random fighter.

​

(let [fighter (rand-nth (stats))

      fm (->numeric-map fighter)

      finto #(first (into [] % [fm]))]

  (println

   (format "Someone is %s years old with %s losses"

           (finto x-age)

           (finto x-losses))))

(defn get-numeric-stats [xform]

  (sequence (comp x-numeric-map

                  xform)

            (stats)))

​

;; Testing with x-age

​

(->> x-age

     get-numeric-stats

     rand-nth

     (format "%s is a random age")

     pprint)

;; Freq finding fn

​

(defn frequent [coll]

  (let [uniq (-> coll distinct sort)

        freq (fn [x coll]

               (let [t (transient [])]

                 (doseq [v coll]

                   (if (= x v) (conj! t v)))

                 (count t)))]

    (map #(hash-map :value %

                    :count (freq % coll))

         uniq)))

​

;; Similar to plot/histogram

​

(defn frequent-chart [coll & opts]

  (let [freq (frequent coll)

        labels (map :value freq)

        plots (map :count freq)

        data [labels plots]

        call (if-not (seq opts)

               data

               (into data opts))]

    (apply plot/bar-chart call)))

​

;; Generate chart

​

(let [ages (get-numeric-stats x-age)

      sorted-ages (sort ages)            

      opts [:plot-size 600

            :aspect-ratio 2.5]

       xys (map #(let [{x :value y :count} %]

                   [x y])

                (frequent ages))]

  ;; Chart Header

  [(->html [:div

             [:h1 "Age of fighters"]

            [:h2 "x = age"] 

            [:h2 "y = number of fighters"]])

   ;; Bar Chart

   (plot/compose

    (apply frequent-chart

           ages

           :color "red"

           opts)

     ;; Line Graph

​

    (apply plot/list-plot

           xys

           :color "brown"

           :joined true

           opts))])

;; Gender identifiers

​

(defn female?

  [fighter]

  (boolean

    (try

      (re-find (re-pattern ".*women.*")

               (-> fighter

                   (get-in ["UFCWeightClass"

                            "Description"]

                           "default-is-male")

                   s/lower-case))

      (catch NullPointerException ex

          ;; Fighter has a nil description

          ;; assuming male

          false))))

​

(defn male?

  [fighter]

  (not (female? fighter)))

​

;; Fighters grouped by gender

​

(def females (filter female? (stats)))

​

(def males (filter male? (stats)))

​

;; Chart found/diffs

​

(let [cm (count males)

      cf (count females)

      more (if (= cm cf)

             ["There are an equal amount." 0]

             (condp = (max cm cf)

               cf ["More women than men"

                   (- cf cm)]

               cm ["More men than women"

                   (- cm cf)]))]

  ;; Chart Header

  [(->html [:h1 "Gender of Fighters"])

   ;; Diff Chart 

   (plot/bar-chart ["Female" "Male"] 

                   [(count females) 

                    (count males)]

                   :color "purple")

   ;; Diff Footer

   (->html

    [:div

     [:h2 {:style "color:red;"}

      (first more)]

     [:h2 {:style "color:blue;"}

      (str "Diff Amount: " (second more))]])])

;; Comparative colors

​

(def male-color "deepskyblue")

(def female-color "crimson")

(def tied-color "green")

​

;; Legend Header fn

​

(defn mf-header

  ([] (mf-header male-color

                 female-color

                 tied-color))

  ([male-color

    female-color

    tied-color]

   ;; Header Local HTML Header fn

     (let [-html (fn [s color]

                   [:h2

                    {:style (format "color:%s;" color)}

                    s])]

       ;; Return HTML

       (->html [:div                

                (-html "Female" female-color)

                (-html "Male" male-color)

                (-html "Tied (when applied)" tied-color)

                (-html "Zero/Blank" "black")]))))

​

;; Compare and Chart fn

​

(defn mf-compare

  ([label

    male

    female]

     (mf-compare label

                 male

                 male-color

                 female

                 female-color

                 tied-color))

  ([label

    male

    male-color

    female

    female-color

    tied-color]

   ;; Local Charting fn

     (let [chart (fn [color value]

                   (plot/bar-chart [label]

                                   [value]

                                   :opacity 0.60

                                   :aspect-ratio 0.25

                                   :plot-size 80

                                   :color color))

           ;; Default Value Display Order

           default [(chart female-color female)

                    (chart male-color male)]]

       ;; Greatest Value Set Behind Lowest (if not tied)

       (if (= male female)      

         (chart tied-color male)

         (apply

          plot/compose

          (if (< male female)

            default

            (reverse default)))))))

​

;; Age comparison between two random fighters

;; one male

;; one female

​

(let [k "Age"

      rand-age #(-> %

                    rand-nth

                    ->numeric-map

                    (get k))]

  ;; Chart Header

  [(->html [:h1 "Comparing Genders - An Example"])

   (mf-header)

   (->html [:h2 "Some random fighters"])

   ;; Comparison Chart

   (mf-compare k

               (rand-age males)

               (rand-age females))])

;; Not the same as get-numeric-stats

​

(defn numeric-map-attr

  [data xform]

  (let [xform (map #(sequence (comp x-numeric-map

                                    xform)

                              [%]))]

    (sequence xform data)))

​

(let [age #(numeric-map-attr % x-age)

      females (age females)

      males (age males)

      xcapable (fn [f]

                 #(->> %

                       (mapcat identity)

                       (apply f)))

      xmax (xcapable max)

      xmin (xcapable min)]

  [(->html [:h1 "Youngest & Oldest Fighters"])

   (mf-header)

   (mf-compare "Oldest"

               (xmax males)

               (xmax females))

   (mf-compare "Youngest"

               (xmin males)

               (xmin females))])

;; Mean, Median, Mode, and Range

​

(defn mean

  [& xs]

  (float

   (/ (reduce + xs)

      (count xs))))

​

(defn median

  [& xs]

  (let [sz (count xs)

        sz (if-not (odd? sz) sz (inc sz))

        half (dec (float (quot sz 2)))]

    (if (<= sz 2)

      (first xs)

      (-> xs

          sort

          (nth half)))))

​

(defn mode

  [& xs]

  (let [t (transient {:count 0 :value 0})]

    (doseq [x xs

            :let [found (filter #{x} xs)

                  c (count found)]]

      (if (< (:count t) c)             

        (assoc! t :count c :value x)))

    (:value t)))

​

(defn range*

  [& xs]

  (let [[l g] ((juxt first last)

               (sort xs))]

    (- g l)))

​

;; Generic Male & Female Comparison Chart

​

(defn mf-compare-*

  [f

   label

   male

   female]

  (let [f (partial apply f)]

    (mf-compare label

                (f male)

                (f female))))

​

;; Chart fn for Mean, Median, Mode, and Range

​

(defn mf-mean

  [male

   female]

  (mf-compare-* mean "Mean" male female))

​

(defn mf-median

  [male

   female]

  (mf-compare-* median "Median" male female))

​

(defn mf-mode

  [male

   female]

  (mf-compare-* mode "Mode" male female))

​

(defn mf-range

  [male

   female]

  (mf-compare-* range* "Range" male female))

​

;; A combination of calculations

​

(defn m3r

  [male

   female]

  (for [[t f] [["Mean" mf-mean]

               ["Median" mf-median]

               ["Mode" mf-mode]

               ["Range" mf-range]]]

    (f male female)))

​

;; An Example of M3R

​

[(->html [:h1 "Fake Numbers - A M3R Example"])

 (mf-header)

 (m3r [1 2 3] [4 5 6])]

(defn numeric-map-attr-x*

  [data xform]

  (reduce into

          []

          (numeric-map-attr data xform)))

​

(defn females-numeric-x

  [xform]

  (numeric-map-attr-x* females xform))

​

(defn fnx

  [xform]

  (females-numeric-x xform))

​

(defn males-numeric-x

  [xform]

  (numeric-map-attr-x* males xform))

​

(defn mnx

  [xform]

  (males-numeric-x xform))

​

[(->html [:h1 "Fighter Age M3R"])

 (mf-header)

 (m3r (mnx x-age)

      (fnx x-age))]

(map (fn [[s x]]

       (vector

        (->html [:h1 (format "Fighter %s M3R" s)])

        (mf-header)

        (m3r (mnx x)

             (fnx x))))

     [["Age" x-age]

      ["AverageFightTime_Seconds" x-average-fight-time-seconds]

      ["Current" x-current]

      ["Draws" x-draws]

      ["Height" x-height]

      ["KDAverage" x-kd-average]

      ["Losses" x-losses]

      ["NoContests" x-no-contests]

      ["Previous" x-previous]

      ["Reach" x-reach]

      ["SApM" x-sapm]

      ["SLpM" x-slpm]

      ["StrikingAccuracy" x-striking-accuracy]

      ["StrikingDefense" x-striking-defense]

      ["SubmissionsAverage" x-submissions-average]

      ["TakedownAccuracy" x-takedown-accuracy]

      ["TakedownDefense" x-takedown-defense]

      ["Weight" x-weight]

      ["Wins" x-wins]])