quiz.cljs

(ns hexlet.quiz
  (:require
    [hexlet.helpers :as h]
    [ajax.core :refer [POST]]
    [goog.dom :as gd]
    [cljs.core.async :as a]
    [quiescent :as q :include-macros true]
    [quiescent.dom :as d])
  (:require-macros [cljs.core.async.macros :as am]))

(enable-console-print!)

(q/defcomponent QuizStatBox
  [{quizzes :quizzes}]
  (let [lesson-quizzes-count (:lesson_quizzes_count h/gon)
        percent (* 100 (/ (- lesson-quizzes-count (count quizzes)) lesson-quizzes-count))
        formatted-percent (str percent "%")]
    (d/div {}
           (d/div {:className "progress"}
                  (d/div {:className "progress-bar" :style {:width formatted-percent}}
                         formatted-percent))
           (d/p {}
                (js/t "web.lessons.quiz.quizzes_count")
                lesson-quizzes-count)
           (d/p {}
                (js/t "web.lessons.quiz.rest_quizzes_count")
                (count quizzes)))))

(q/defcomponent QuizBox
  [{finished :finished current :current} push]
  (if finished
    (d/div {} "двигаем дальше")
    (let [quiz (:quiz current)
          result (:result current)
          classes (h/cx {:btn true :btn-success result :btn-warning (not result)})
          answer-key (str "web.lessons.quiz." (if result "right_answer" "wrong_answer"))]
      (d/div {}
             (d/h3 {} (:question quiz))
             (d/form {:className "simple_form"
                      :onSubmit #(push % submit-answer)}
                     (d/div {:dangerouslySetInnerHTML {:__html (:filtered_source quiz)}})
                     (condp = result
                       nil (d/input {:type "submit"
                                     :className "btn btn-default"
                                     :value (js/t "web.lessons.quiz.check")})
                       (d/input {:type "submit"
                                 :onClick #(push % next-question)
                                 :className classes
                                 :value (js/t "web.lessons.quiz.next")})))
             (when result
               (d/p {} (js/t answer-key)))))))

(defn ^:export main
  "Application entry point"
  []
  (let [chan (a/chan)
        state (init-state)
        atom-state (atom state)
        push #(do (.preventDefault %1) (am/go (a/>! chan [%1, %2])))]
    (init-updates atom-state chan push)
    (am/go (a/>! chan [nil start]))))

(defn init-updates
  [state chan push]
  (am/go (while true
           (let [[e update-fn] (a/<! chan)]
             (swap! state update-fn e)
             (q/render (QuizStatBox (deref state))
                       (gd/getElement "quiz_stat"))
             (q/render (QuizBox (deref state) push)
                       (gd/getElement "quiz"))))))

(defn init-state
  []
  (let [quizzes (:quizzes h/gon)]
    {:quizzes quizzes
     :current {:quiz (first quizzes) :result nil}}))

(defn start
  [state e]
  state)

(defn submit-answer
  [state e]
  ;; (POST (.- js/Routes))
  (POST (.-api-lesson_quiz_results_path js/Routes ["1", "2"])
        {:params {:ehu "lala"}})
  (assoc-in state [:current :result] true))

(defn next-question
  [{current :current quizzes :quizzes} e]
  (let [next-quiz (second quizzes)
        rest-quizzes (rest quizzes)]
    (if next-quiz
      {:current {:quiz next-quiz :result nil}
       :quizzes (if (:result current) rest-quizzes (conj rest-quizzes (:quiz current)))}
      {:finished true})))