(ns chef.logic.categories
  (:require [clojure.string :as cstr]
            [honey.sql :as sql]
            [next.jdbc :as jdbc]
            [chef.database :as cdb]
            [chef.utils :as cutils]))

(defn get-all-categories []
  (cutils/dprintln "get-all-categories")
  (->> {:select [:*]
        :from   [:categories]}
       sql/format
       (jdbc/execute! @cdb/db)
       (filter #(pos? (:categories/id %)))                  ; Filter out root category
       ))

(defn get-category [id]
  (cutils/dprintln "get-category")
  (->> {:select [:*]
        :from   [:categories]
        :where  [:= :id id]}
       sql/format
       (jdbc/execute! @cdb/db)
       first))

(defn find-categories-with-parent [parent-id]
  (cutils/dprintln "find-categories-with-parent")
  (->> {:select [:*]
        :from   [:categories]
        :where  [:= :parent parent-id]}
       sql/format
       (jdbc/execute! @cdb/db)))

(defn create-category! [parent]
  (cutils/dprintln "create-category!")
  (->> {:insert-into [:categories]
        :values      [{:name   "New category"
                       :parent parent}]}
       sql/format
       (jdbc/execute! @cdb/db)))

(defn- delete-category! [id]
  (cutils/dprintln "delete-category!")
  (->> {:delete-from [:categories]
        :where       [:= :id id]}
       sql/format
       (jdbc/execute! @cdb/db)))

(defn- delete-category-children! [id]
  (cutils/dprintln "delete-category-children!")
  (doseq [child (find-categories-with-parent id)]
    (delete-category! (:categories/id child))
    (delete-category-children! (:categories/id child))))

(defn delete-category-and-children! [id]
  (cutils/dprintln "delete-category-and-children!")
  (delete-category! id)
  (delete-category-children! id))

(defn update-category! [id updates]
  (cutils/dprintln "update-category!")
  (->> {:update :categories
        :set    updates
        :where  [:= :id id]}
       sql/format
       (jdbc/execute! @cdb/db)))

(defn get-parents [category]
  (cutils/dprintln "get-parents")
  (loop [parents (list)
         category category]
    (let [updated-parents (conj parents category)]
      (if (not= -1 (:categories/parent category))
        (recur updated-parents
               (get-category (:categories/parent category)))
        updated-parents))))

(defn generate-path [category]
  (cutils/dprintln "generate-path")
  (->> category
       get-parents
       (map #(:categories/name %))
       (cstr/join " > ")))