(ns lezer.controller.routes
  (:require lezer.view.main :refer [index-html])
  (:require lezer.view.author :refer [author-html])
  (:require lezer.module.greet :as g)
  (:require phel.router :as r)
  (:require phel.http :as h)
  (:require phel.pdo)
  (:require phel.string :as str)
  (:require lezer.db :refer [conn]))

(defn get-books []
  (pdo/select conn "select * from books"))

(defn get-authors-by-book [book]
  (pdo/select
   conn
   "select * from authors where id in (select author_id from authors_books where book_id = :book_id)"
   {:book_id (:id book)}))

(defn create-book [fields]
  (pdo/insert conn :books fields))

(defn get-or-create-author-by-name [fields]
  (or (pdo/fetch-column
       (pdo/query conn "select id from authors where name = :name"
                  {:name (:name fields)}))
      (pdo/insert conn :authors fields)))

(defn get-book-pages-by-id [book-id]
  (pdo/fetch-column (pdo/query conn "select pages from books where id = :id" {:id book-id})))

(defn create-book-session [fields]
  (pdo/insert conn :books_sessions fields))

(defn create-session-progress [fields]
  (pdo/insert conn :sessions_progress fields))

(defn index-handler [req router]
  (let [books (for [b :in (get-books)]
                {:book b
                 :authors (get-authors-by-book b)})]
    (h/response-from-map {:status 200
                          :body (index-html books router)})))

(defn get-author-by-id [id]
  (first (pdo/select conn "select * from authors where id = :author_id" {:author_id id})))

(defn get-books-by-author-id [id]
  (pdo/select conn "select * from books where id in (select book_id from authors_books where author_id = :author_id)" {:author_id id}))

(defn add-author-to-book [book-id fields]
  (pdo/insert conn :authors_books {:book_id book-id
                                   :author_id (get-or-create-author-by-name fields)}))

(defn book-create-handler [request]
  (let [title (get-in request [:parsed-body "title"])
        subtitle (get-in request [:parsed-body "subtitle"])
        authors (str/split (get-in request [:parsed-body "author"]) #",")
        pages (get-in request [:parsed-body "pages"])]
    (pdo/with-transaction conn
      (let [time (php/time)
            book-id (create-book {:title title
                                  :subtitle subtitle
                                  :pages pages
                                  :created_at time
                                  :updated_at time})]
        (for [a :in authors]
          (add-author-to-book book-id {:name (str/trim a)
                                       :created_at time
                                       :updated_at time})))))
  (h/response-from-map {:status 301 :headers {:location "/"}}))

(defn book-session-create-handler [request]
  (let [id (get-in request [:attributes :match :path-params :id])
        pages (get-book-pages-by-id id)
        time (php/time)]
    (pdo/with-transaction conn
      (let [session-id (create-book-session {:book_id id
                                             :status "started"
                                             :started_at time
                                             :created_at time
                                             :updated_at time})]
        (create-session-progress {:session_id session-id
                                  :progress 0
                                  :total pages
                                  :created_at time
                                  :updated_at time}))))
  (h/response-from-map {:status 301 :headers {:location "/"}}))

(defn author-view-handler [req]
  (let [id (get-in req [:attributes :match :path-params :id])
        author (get-author-by-id id)
        books (get-books-by-author-id id)]
    (h/response-from-map {:status 200 :body (author-html author books)})))