(ns coronavirus-charts.handler
  (:require
    [coronavirus-charts.middleware :as middleware]
    [coronavirus-charts.layout :refer [error-page]]
    [coronavirus-charts.routes.home :refer [home-routes]]
    [reitit.ring :as ring]
    [ring.middleware.content-type :refer [wrap-content-type]]
    [ring.middleware.webjars :refer [wrap-webjars]]
    [coronavirus-charts.env :refer [defaults]]
    [mount.core :as mount]))

(mount/defstate init-app
  :start ((or (:init defaults) (fn [])))
  :stop  ((or (:stop defaults) (fn []))))

(mount/defstate app-routes
  :start
  (ring/ring-handler
    (ring/router
      [(home-routes)])
    (ring/routes
      (ring/create-resource-handler
        {:path "/"})
      (wrap-content-type
        (wrap-webjars (constantly nil)))
      (ring/create-default-handler
        {:not-found
         (constantly (error-page {:status 404, :title "404 - Page not found"}))
         :method-not-allowed
         (constantly (error-page {:status 405, :title "405 - Not allowed"}))
         :not-acceptable
         (constantly (error-page {:status 406, :title "406 - Not acceptable"}))}))))

(defn app []
  (middleware/wrap-base #'app-routes))

(ns coronavirus-charts.sessions
  (:require
   [tick.alpha.api :as t]
   [clojure.pprint :refer [pprint]]
   [clj-http.client :as client]
   [clara.rules :refer :all]
   [clara.rules.accumulators :as acc]
   [coronavirus-charts.chartwell :as cw]
   [coronavirus-charts.charts :as charts]
   [coronavirus-charts.data :as external-data]
   [cheshire.core :as cheshire]
   [clojure.string :as string]))

(defn is-within-time?
  [time tolerance]
  (< (t/hours (t/between time (t/inst))) tolerance))

(defn is-same-day?
  [t1 t2]
  (= (t/date t1) (t/date t2)))

(defn is-date? [date-string]
  (let [date (try (t/date date-string) (catch Exception e false))]
  (if date
    true
    false)))

(defn parse-path
  [path]
  (flatten
   (map (fn [v] (string/split v #","))
        (string/split path #"/"))))

(defrecord WebRequest [url])
(defrecord ParsedRequest [path argument])

(defrecord LocationRequest [path
                            location-name
                            country-code
                            location-report])

(defrecord DateRequest [path date])

(defrecord NavFragment [path nav-type body])
(defrecord ChartFragment [path chart-type body])
(defrecord RenderedPage [path html])

(defrecord GlobalReport [source-name
                         source-url
                         last-queried
                         latest])

(defrecord LocationReport [source-name
                           source-url
                           country
                           country-code
                           country-population
                           province
                           last-updated
                           coordinates
                           timelines
                           latest])

(defn create-location-report
  [r]
  (let [latest (:latest r)]
    (LocationReport.
     "Johns Hopkins University"
     "https://github.com/CSSEGISandExternal-Data/COVID-19"
     (:country r)
     (:country_code r)
     (:country_population r)
     (:province r)
     (t/inst (:last_updated r))
     (:coordinates r)
     (:timelines r)
     {:confirmed (:confirmed latest)
      :deaths (:deaths latest)})))

(defn create-jhu-global-report
  [stats]
  (GlobalReport.
   "Johns Hopkins University"
   "https://github.com/CSSEGISandExternal-Data/COVID-19"
   (t/inst)
   stats))

(defn create-nav [nav-data]
  (let [locations (get nav-data "Location")
        dates  (get nav-data "Date")]
    (list
     (charts/make-nav (map :body locations) "locations" "Locations")
     (charts/make-nav (map :body dates) "dates" "Dates"))))

(defrule parse-request
  [WebRequest
   (= ?url url)
   (= ?arguments (parse-path ?url))]
  =>
  (insert-all! (map (fn [arg]
                      (if (not (string/blank? arg))
                        (ParsedRequest. ?url arg))) ?arguments)))

(defrule print-args
  [ParsedRequest (= ?arg argument)]
  =>
  (println ?arg))

(defrule create-latest-chart-by-country-code
  [LocationRequest
   (= ?path path)
   (= ?report location-report)]
  =>
  (insert-all! (list
                (ChartFragment. ?path "bar" (cw/latest-bar ?report))
                (ChartFragment. ?path "table" (cw/latest-table ?report))
                (ChartFragment. ?path "source" (cw/source-box ?report)))))

(defrule create-home-page-charts
  [WebRequest
   (= ?url url)
   (or
    (= "/" ?url)
    (string/blank? ?url))]
  [?global-report <- (acc/max :last-queried :returns-fact true) :from [GlobalReport (= ?latest latest)]]
  =>
  (insert-all! (list
                (ChartFragment. ?url "global" (cw/global-bar ?global-report))
                (ChartFragment. ?url "table" (cw/latest-table ?global-report)))))

(defrule create-chart-page
  [?chart-fragments <- (acc/all) :from [ChartFragment (= ?path path)]]
  [?nav-fragments <- (acc/grouping-by :nav-type) :from [NavFragment (= ?path path)]]
  =>
  (insert! (RenderedPage. ?path
                          (charts/base-chart "Recorded Coronavirus (COVID-19) Cases"
                                             (create-nav ?nav-fragments)
                                             (map :body ?chart-fragments)))))

(defrule update-location-reports
  [:not [LocationReport (is-within-time? last-updated 48)]]
  =>
  (println "doing an update")
  (insert-all! (map create-location-report (external-data/get-all-timelines-jhu))))

(defrule parse-locations
  [?parsed <- ParsedRequest (= ?arg argument) (= ?path path)]
  [?report <- LocationReport (= ?country-code country-code) (= ?country country)]
  [:test (or
          (= ?country-code (string/upper-case ?arg))
          (= (string/lower-case ?country) (string/lower-case ?arg)))]
  =>
  (insert! (LocationRequest. ?path (:country ?report) (:country-code ?report) ?report))
  (pprint (:timelines ?report))
  (insert! (NavFragment. ?path "Location" (:country ?report))))

(defrule parse-dates
  [ParsedRequest (= ?arg argument) (= ?path path)]
  [:test (is-date? ?arg)]
  =>
  (println "parsing dates")
  (insert! (DateRequest. ?path (t/date ?arg)))
  (insert! (NavFragment. ?path "Date" (t/date ?arg))))

(defquery query-country
  [:?country-code]
  [?report <- LocationReport (= ?country-code country-code)])

(defquery query-chart-request
  [:?path]
  [ChartFragment (= ?path path) (= ?chart-type chart-type) (= ?body body)])

(defquery query-location-request
  [:?path]
  [LocationRequest (= ?path path) (= ?location-name location-name)])

(defquery query-rendered-page
  [:?path]
  [RenderedPage (= ?path path) (= ?html html)])

(defquery query-parsed-request
  [:?path]
  [ParsedRequest (= ?path path) (= ?argument argument)])

(defquery all-parsed [] [ParsedRequest (= ?path path)])

(defquery all-locations [] [LocationRequest (= ?path path) (= ?location-name location-name)])

(defn search-location-reports [country-code]
  (let [facts  (map create-location-report (external-data/get-all-timelines-jhu))
        session (-> (mk-session [query-country])
                    (insert-all facts)
                    (fire-rules))]
    (query session query-country :?country-code country-code)))

(def jhu-session (atom (-> (mk-session [parse-request
                                        query-country
                                        update-location-reports
                                        create-home-page-charts
                                        create-latest-chart-by-country-code
                                        create-chart-page
                                        all-locations
                                        parse-locations
                                        query-parsed-request
                                        query-chart-request
                                        query-location-request
                                        query-rendered-page
                                        parse-dates
                                        ])
                           (insert-all (map create-location-report (external-data/get-all-timelines-jhu)))
                           (insert (create-jhu-global-report (external-data/get-latest-global-jhu)))
                           (fire-rules))))

(defn render-web-request
  [path]
  (-> @jhu-session
      (insert (->WebRequest path))
      (fire-rules)
      (query query-rendered-page :?path path)
      (first)
      (:?html)))

(defn search-reports-by-country [session country-code]
  (fire-rules session)
  (:?report
   (first (query session query-country  "?country-code" country-code))))

(ns coronavirus-charts.nrepl
  (:require
    [nrepl.server :as nrepl]
    [clojure.tools.logging :as log]))

(defn start
  [{:keys [port bind transport-fn handler ack-port greeting-fn]}]
  (try
    (log/info "starting nREPL server on port" port)
    (nrepl/start-server :port port
                        :bind bind
                        :transport-fn transport-fn
                        :handler handler
                        :ack-port ack-port
                        :greeting-fn greeting-fn)
    (catch Throwable t
      (log/error t "failed to start nREPL")
      (throw t))))

(defn stop [server]
  (nrepl/stop-server server)
  (log/info "nREPL server stopped"))

(ns coronavirus-charts.core
  (:require
    [coronavirus-charts.handler :as handler]
    [coronavirus-charts.nrepl :as nrepl]
    [luminus.http-server :as http]
    [coronavirus-charts.config :refer [env]]
    [clojure.tools.cli :refer [parse-opts]]
    [clojure.tools.logging :as log]
    [mount.core :as mount])
  (:gen-class))

(Thread/setDefaultUncaughtExceptionHandler
  (reify Thread$UncaughtExceptionHandler
    (uncaughtException [_ thread ex]
      (log/error {:what :uncaught-exception
                  :exception ex
                  :where (str "Uncaught exception on" (.getName thread))}))))

(def cli-options
  [["-p" "--port PORT" "Port number"
    :parse-fn #(Integer/parseInt %)]])

(mount/defstate ^{:on-reload :noop} http-server
  :start
  (http/start
    (-> env
        (assoc  :handler (handler/app))
        (update :port #(or (-> env :options :port) %))))
  :stop
  (http/stop http-server))

(mount/defstate ^{:on-reload :noop} repl-server
  :start
  (when (env :nrepl-port)
    (nrepl/start {:bind (env :nrepl-bind)
                  :port (env :nrepl-port)}))
  :stop
  (when repl-server
    (nrepl/stop repl-server)))

(defn stop-app []
  (doseq [component (:stopped (mount/stop))]
    (log/info component "stopped"))
  (shutdown-agents))

(defn start-app [args]
  (doseq [component (-> args
                        (parse-opts cli-options)
                        mount/start-with-args
                        :started)]
    (log/info component "started"))
  (.addShutdownHook (Runtime/getRuntime) (Thread. stop-app)))

(defn -main [& args]
  (start-app args))

(ns coronavirus-charts.data
    (:require
     [clojure.pprint :refer [pprint]]
     [clj-http.client :as client]
     [cheshire.core :as cheshire]
     [clojure.string :as string]
     [tick.alpha.api :as t]
     [clojure.walk :refer [stringify-keys]]))

(defn fetch-data
  [url]
  (cheshire/parse-string (:body (client/get url {:accept :json}))
                         true))

(defn extract-location
  [loc]
  {:id (:id loc)
   :latest (:latest loc)})

(defn get-latest-global-jhu
  []
  (let [data (:latest (fetch-data "http://covid19api.xapix.io/v2/latest"))]
    {:confirmed (:confirmed data) :deaths (:deaths data)}))

(defn get-all-locations-jhu
  []
  (let [data (fetch-data "http://covid19api.xapix.io/v2/locations")]
    (:locations data)))

(defn get-all-timelines-jhu
  []
  (let [data (fetch-data "http://covid19api.xapix.io/v2/locations?timelines=true")]
    (:locations data)))

(def jhu-timelines (get-all-timelines-jhu))

(defn extract-timeline-by-key [timeline key]
  (map (fn [[d v]]
       [(t/date (t/inst d)) v])
       (stringify-keys (get-in timeline [key :timeline]))))

(defn extract-timeline-metadata [report]
  {:coordinates (:coordinates report)
   :country-code (:country_code report)
   :latest {:confirmed (:confirmed (:latest report))
            :deaths (:deaths (:latest report))}
   :country-population (:country_population report)
   :last-updated (t/inst (:last_updated report))
   :province (:province report)
   :country (:country report)})

(defn extract-dated-cases [timeline]
  (let [confirmed (extract-timeline-by-key timeline :confirmed)
        deaths (extract-timeline-by-key timeline :deaths)]
    (zipmap confirmed deaths)))

(defn date-readings [report]
  "Given the a parsed jhu-report, return list of maps
   representing the # of confirmed cases for each individual day at
   that location. ({:date X :deaths Y :confirmed Z}, ...)"
  (let [time-reports (extract-dated-cases (:timelines report))]
    (map (fn [[deaths confirmed]]
           {:date (first deaths)
            :deaths (second deaths)
            :confirmed (second confirmed)}) time-reports)))

(pprint (date-readings  (first jhu-timelines)))
(pprint (take 2 (map date-readings jhu-timelines)))

(defn compose-location-time-reports [report]
  (let [location-data (extract-timeline-metadata report)
        case-data (date-readings report)]
    (map (fn [c]
           (merge c location-data))
         case-data)))

(pprint (take 2 (compose-location-time-reports (first jhu-timelines))))

(def location-time-reports (map compose-location-time-reports jhu-timelines))

(pprint (first location-time-reports))

(defrecord LocationReport2 [source-name
                           source-url
                           country
                           country-code
                           country-population
                           province
                           last-updated
                           coordinates
                           date
                           deaths
                           confirmed
                           latest])

(defn create-location-report
  [{:keys [country
           country-code
           country-population
           province
           last-updated
           coordinates
           date
           deaths
           confirmed
           latest]}
   r]
  (LocationReport2.
   "Johns Hopkins University"
   "https://github.com/CSSEGISandExternal-Data/COVID-19"
   country
   country-code
   country-population
   province
   last-updated
   coordinates
   date
   deaths
   confirmed
   latest))

(ns coronavirus-charts.layout
  (:require
    [clojure.java.io]
    [selmer.parser :as parser]
    [selmer.filters :as filters]
    [markdown.core :refer [md-to-html-string]]
    [ring.util.http-response :refer [content-type ok]]
    [ring.util.anti-forgery :refer [anti-forgery-field]]
    [ring.middleware.anti-forgery :refer [*anti-forgery-token*]]
    [ring.util.response]))

(parser/set-resource-path!  (clojure.java.io/resource "html"))
(parser/add-tag! :csrf-field (fn [_ _] (anti-forgery-field)))
(filters/add-filter! :markdown (fn [content] [:safe (md-to-html-string content)]))

(defn render
  [request template & [params]]
  (content-type
    (ok
      (parser/render-file
        template
        (assoc params
          :page template
          :csrf-token *anti-forgery-token*)))
    "text/html; charset=utf-8"))

(defn error-page
  [error-details]
  {:status  (:status error-details)
   :headers {"Content-Type" "text/html; charset=utf-8"}
   :body    (parser/render-file "error.html" error-details)})

(ns coronavirus-charts.middleware.formats
  (:require
    [cognitect.transit :as transit]
    [luminus-transit.time :as time]
    [muuntaja.core :as m]))

(def instance
  (m/create
    (-> m/default-options
        (update-in
          [:formats "application/transit+json" :decoder-opts]
          (partial merge time/time-deserialization-handlers))
        (update-in
          [:formats "application/transit+json" :encoder-opts]
          (partial merge time/time-serialization-handlers)))))

(ns coronavirus-charts.charts
    (:require [cheshire.core :as cheshire]
            [hiccup.core :refer [h]]
            [coronavirus-charts.chartwell :as cw])
    (:use [hiccup.page :only (html5 include-css include-js)]))

(defn reel-script []
  [:script "(function() {
  const className = 'chart-boards';
  const reels = Array.from(document.querySelectorAll(`.${className}`));
  const toggleOverflowClass = elem => {
    elem.classList.toggle('overflowing', elem.scrollWidth > elem.clientWidth);
  };
  for (let reel of reels) {
    if ('ResizeObserver' in window) {
      new ResizeObserver(entries => {
        toggleOverflowClass(entries[0].target);
      }).observe(reel);
    }
    if ('MutationObserver' in window) {
      new MutationObserver(entries => {
        toggleOverflowClass(entries[0].target);
      }).observe(reel, {childList: true});
    }
  }
})();"])

(defn make-nav [values class title]
  [:div.nav {:class class}
   [:h2 title]
   [:ul
    (map (fn [val]
           [:li val]) values)]])

(defn base-chart [heading nav content]
  (html5 [:head
          [:title "coronavirus-charts.org"]
          (include-css "/css/screen.css")]
         [:body
          [:div.citation-strip nav [:h1 heading]]
          [:div.center
           content]
          (reel-script)]))

(ns coronavirus-charts.config
  (:require
    [cprop.core :refer [load-config]]
    [cprop.source :as source]
    [mount.core :refer [args defstate]]))

(defstate env
  :start
  (load-config
    :merge
    [(args)
     (source/from-system-props)
     (source/from-env)]))

(ns coronavirus-charts.oz
  (:require [oz.core :as oz]))

(oz/start-server!)
(defn play-data [& names]
  (for [n names
        i (range 20)]
    {:time i :item n :quantity (+ (Math/pow (* i (count n)) 0.8) (rand-int (count n)))}))

(def line-plot
  {:data {:values (play-data "monkey" "slipper" "broom")}
   :encoding {:x {:field "time" :type "quantitative"}
              :y {:field "quantity" :type "quantitative"}
              :color {:field "item" :type "nominal"}}
   :mark "line"})

(oz/view! line-plot)

(def viz
  [:div
    [:h1 "Look Up Chicken Little"]
    [:p "A couple of small charts"]
    [:div {:style {:display "flex" :flex-direction "row"}}
     [:vega-lite line-plot]]
    [:p "A wider, more expansive chart"]
    [:h2 "If ever, oh ever a viz there was, the vizard of oz is one because, because, because..."]
   [:p "Because of the wonderful things it does"]])

(oz/export! viz "export-test.html")

(oz/build! line-plot)

(ns coronavirus-charts.facts)

(defrecord JHUReport [source-name
                           source-url
                           country
                           country-code
                           country-population
                           province
                           last-updated
                           coordinates
                           date
                           deaths
                           confirmed
                      latest])

(ns coronavirus-charts.middleware
  (:require
    [coronavirus-charts.env :refer [defaults]]
    [cheshire.generate :as cheshire]
    [cognitect.transit :as transit]
    [clojure.tools.logging :as log]
    [coronavirus-charts.layout :refer [error-page]]
    [ring.middleware.anti-forgery :refer [wrap-anti-forgery]]
    [coronavirus-charts.middleware.formats :as formats]
    [muuntaja.middleware :refer [wrap-format wrap-params]]
    [coronavirus-charts.config :refer [env]]
    [ring.middleware.flash :refer [wrap-flash]]
    [immutant.web.middleware :refer [wrap-session]]
    [ring.middleware.defaults :refer [site-defaults wrap-defaults]]))

(defn wrap-internal-error [handler]
  (fn [req]
    (try
      (handler req)
      (catch Throwable t
        (log/error t (.getMessage t))
        (error-page {:status 500
                     :title "Something very bad has happened!"
                     :message "We've dispatched a team of highly trained gnomes to take care of the problem."})))))

(defn wrap-csrf [handler]
  (wrap-anti-forgery
    handler
    {:error-response
     (error-page
       {:status 403
        :title "Invalid anti-forgery token"})}))

(defn wrap-formats [handler]
  (let [wrapped (-> handler wrap-params (wrap-format formats/instance))]
    (fn [request]
      ;; disable wrap-formats for websockets
      ;; since they're not compatible with this middleware
      ((if (:websocket? request) handler wrapped) request))))

(defn wrap-base [handler]
  (-> ((:middleware defaults) handler)
      wrap-flash
      (wrap-session {:cookie-attrs {:http-only true}})
      (wrap-defaults
        (-> site-defaults
            (assoc-in [:security :anti-forgery] false)
            (dissoc :session)))
      wrap-internal-error))

(ns coronavirus-charts.routes.home
  (:require
   [coronavirus-charts.layout :as layout]
   [clojure.java.io :as io]
   [clojure.string :as string]
   [coronavirus-charts.middleware :as middleware]
   [coronavirus-charts.sessions :refer :all]
   [ring.util.response]
   [ring.util.http-response :as response]
   [clara.rules :refer :all]))

(defn home-page [request]
  (layout/render request "home.html" {:docs (-> "docs/docs.md" io/resource slurp)}))

(defn about-page [request]
  (println  (string/split (:path-info request) #"/"))
  (layout/render request "about.html"))

(defn chart-page [request]
  (let [path (:path-info request)
        params  (string/split path #"/")]
    (println params)
    (layout/render request "home.html")))

(defn home-routes []
  [
   {:middleware [middleware/wrap-csrf
                 middleware/wrap-formats]}
   ["/*" {:get (fn [resp]
                 (-> (response/ok (render-web-request (:path-info resp)))
                     (response/header "content-type" "text/html")))}]])

(ns coronavirus-charts.chartwell
  (:require [clojure.math.numeric-tower :as math]))

(defn chart-segment
  [content color class]
;;  ^{:key (random-uuid)} Don't think that this is necessary in clj
  [:span {:style (str "color:" color)
          :class (str "chart-segment " class)}
   (reduce str content)])

(defn herb-vertical-bars [sizes colors grid class-func]
  [:div.vertical-bars
   (cons [:span {:class "vertical-bars-grid"} (str grid "+")]
         (map
          (fn [[size color]] (chart-segment (str size "+")
                                               color
                                               (class-func size color)))
          (map vector sizes colors)))])

(defn v-bar-scale [v target]
  (int (math/ceil (* 100 (/ v target)))))

(defn target-scale [dataset]
  (apply max dataset))

(defn vertical-bars [sizes colors grid class]
  (let [target (target-scale sizes)]
    [:div.vertical-bars
     (cons
      [:span {:class "vertical-bars-grid"} (str grid "+")]
      (map
       (fn [[size color]] (chart-segment (str (v-bar-scale size target) "+")
                                            color
                                            class))
       (map vector sizes colors)))]))

(defn source-box [r]
  (let [source-name (:source-name r)
        source-url (:source-url r)]
    [:p.sources "Source: "
     [:a {:href source-url} source-name]
     " via "
     [:a {:href "https://xapix-io.github.io/covid-data/"} "xapix" ]]))

(defn latest-bar [r]
  (let [latest (:latest r)
        c (:confirmed latest)
        d (:deaths latest)]
    [:div.bar-chart
     [:h2 (:country r)]
     (vertical-bars [c d] ["#dab101" "#110809"] "d" "latest-bar")]))

(defn global-bar [g]
  (let [latest (:latest g)
        c (:confirmed latest)
        d (:deaths latest)]
    [:div.bar-chart
     [:h2 "Global Cases"]
     (vertical-bars [c d] ["#dab101" "#110809"] "d" "latest-bar")]))

(defn latest-table
  [r]
  (let [latest (:latest r)
        c (:confirmed latest)
        d (:deaths latest)]
    [:table.blocky-table
     [:thead
      [:tr
       [:th "Confirmed"]
       [:th "Deaths"]]]
     [:tbody
      [:tr
       [:td c]
       [:td d]]]]))

(ns coronavirus-charts.sources.jhu
  (:require
   [coronavirus-charts.data :as d]
   [coronavirus-charts.facts :refer [hello]]
   [clojure.pprint :refer [pprint]]
   [clojure.walk :refer [stringify-keys]]
   [tick.alpha.api :as t]
   [where.core :refer [where]]
   [com.rpl.specter :refer :all]))

(defn get-latest-global-jhu
  []
  (let [data (:latest (d/fetch-data "http://covid19api.xapix.io/v2/latest"))]
    {:confirmed (:confirmed data) :deaths (:deaths data)}))

(defn get-all-locations-jhu
  []
  (let [data (d/fetch-data "http://covid19api.xapix.io/v2/locations")]
    (:locations data)))

(defn get-all-timelines-jhu
  []
  (let [data (d/fetch-data "http://covid19api.xapix.io/v2/locations?timelines=true")]
    (:locations data)))

(def jhu-timelines (get-all-timelines-jhu))

(defn extract-timeline-by-key [timeline key]
  (map (fn [[d v]]
       [(t/date (t/inst d)) v])
       (stringify-keys (get-in timeline [key :timeline]))))

(defn extract-timeline-metadata [report]
  {:coordinates (:coordinates report)
   :country-code (:country_code report)
   :latest {:confirmed (:confirmed (:latest report))
            :deaths (:deaths (:latest report))}
   :country-population (:country_population report)
   :last-updated (t/inst (:last_updated report))
   :province (:province report)
   :country (:country report)})

(defn extract-dated-cases [timeline]
  (let [confirmed (extract-timeline-by-key timeline :confirmed)
        deaths (extract-timeline-by-key timeline :deaths)]
    (zipmap confirmed deaths)))

(defn date-readings [report]
  "Given the a parsed jhu-report, return list of maps
   representing the # of confirmed cases for each individual day at
   that location. ({:date X :deaths Y :confirmed Z}, ...)"
  (let [time-reports (extract-dated-cases (:timelines report))]
    (map (fn [[deaths confirmed]]
           {:date (first deaths)
            :deaths (second deaths)
            :confirmed (second confirmed)}) time-reports)))

(defn compose-location-time-reports [report]
  (let [location-data (extract-timeline-metadata report)
        case-data (date-readings report)]
    (map (fn [c]
           (merge c location-data))
         case-data)))

(def location-time-reports
  (map compose-location-time-reports jhu-timelines))

(defn create-location-report
  [r]
  (let [{:keys [country
           country-code
           country-population
           province
           last-updated
           coordinates
           date
           deaths
           confirmed
           latest]}
        r]
    (JHUReport.
     "Johns Hopkins University"
     "https://github.com/CSSEGISandExternal-Data/COVID-19"
     country
     country-code
     country-population
     province
     last-updated
     coordinates
     date
     deaths
     confirmed
     latest)))

(def location-report-records
  (transform [ALL ALL] create-location-report location-time-reports))

(count (last location-report-records))

(ns coronavirus-charts.sources.wikipedia)