[;; A user writing an article
 {:db/id #db/id [:db.part/user -100]
  :user/username "john.smith"}
 {:db/id #db/id [:db.part/user -200]
  :category/name "Functional Programming"}
 {:db/id #db/id [:db.part/user -300]
  :article/title "Monads in Pictures"
  :article/author #db/id [:db.part/user -100]
  :article/category #db/id [:db.part/user -200]
  :article/body "http://bit.ly/14mj7WG"}
]

;; Requests and Response are immutable Maps

;; Handlers return Response
(defn what-is-my-ip [request]
  {:status 200
   :headers {"Content-Type" "text/plain"}
   :body (:remote-addr request)})

;; Middlewares are higher-order functions that transform a handler
(defn wrap-content-type [handler content-type]
  (fn [request]
    (let [response (handler request)]
      (assoc-in response [:headers "Content-Type"] content-type))))

;; Application
(def app
  (-> what-is-my-ip
      (wrap-content-type "text/html")
      (wrap-keyword-params)
      (wrap-params)))

(html
  [:li {:class (if active "active" "")}
    [:a {:href (str "#" path)} name]])

(defn view [data owner]
  (reify
    om/IRenderState
    (render-state [_ {:keys [sample-text]}]
      (let [text (:sample-text data)]
        (html
         [:section {:class "home"}
          [:h1 text]
          [:h2 text]
          [:h3 text]
          [:h4 text]
          [:h5 text]
          [:h6 text]
          [:p.large text]
          [:p.medium text]
          [:p.small text]])))))

(defn clearfix [clazz]
  [clazz {:*zoom 1}
   [:&:before :&:after {:display "table"
                        :content " "
                        :line-height 0}]
   [:&:after {:clear "both"}]])

;; list comprehension
(for [x (range 1 10)
      y (range 1 10)
      :when (and (zero? (rem x y))
                 (even? (quot x y)))]
  [x y])


;; higher order functions over sequences
(map inc [0 1 2 3 4 5 6 7 8 9])

(filter even? (range 10))

(reduce + (range 100))

(partition 2 [:a 1 :b 2 :c 3 :d 4 :e 5])

(remove odd? (range 10))

(take 5 (interleave (repeat "red") (repeat "blue")))

(defn parse-csv [str-in]
  (csv/read-csv str-in :separator \tab))

(defn read-csv [data-in]
  (with-open [f (io/reader (io/resource data-in))]
    (doall (parse-csv f))))

(defn parse-json [data-in]
  (->> data-in
       (map #(nth % 4)) ;; 5th item is json data
       (apply str)
       (json/parse-string)
       walk/keywordize-keys))

(defn to-data [res-in]
  (with-open [res (io/reader (io/resource res-in))]
    (->> res
         (parse-csv)
         (parse-json)
         (timeify))))

(def gutter (px 20))

(def typesetting
  (list
   (typo/typeset-body typo/defaults :golden)))

(def grids
  (list (typo/baseline (rgba 0 0 255 0.5) (px 2))
        (grid/create ".grid" gutter)
        (grid/wrap-widths 978)
        (grid/create-nested-units)
        (grid/nuke-gutters-and-padding)
        (grid/respond-small (:mobile breakpoints) gutter)
        (grid/respond-medium (:tablet breakpoints))))

(def styles
  (css (merge grids typesetting)))

;; a bad example
(defn make-serifs [selector families]
  (fn [declarations]
    (let [styles (selector declarations)]
      (conj styles (font (:garamond families) 3 600 0.5 2)))))

;; slightly better
(defn scale-type [selector params]
  (fn [declarations]
    (let [styles (selector declarations)]
      (conj styles
            (at-media {:min-width (get-in params [:breakpoints :mobile])}
                      [:& {:font-size (* 1.5 (:min-font params))}])
            (at-media {:min-width (get-in params [:breakpoints :tablet])}
                      [:& {:font-size (* 1.75 (:min-font params))}])
            (at-media {:min-width (get-in params [:breakpoints :laptop])}
                      [:& {:font-size (* 2.25 (:min-font params))}])))))

(defn headings [declarations]
  [:h1 :h2])

(-> headings
    (scale-type settings)
    (make-serifs brand-fonts)
    (make-sans-brand-fonts)
    (grid/create {:columns 3})