(ns auto-ap.db.checks
  (:require [auto-ap.db.utils :refer [clj->db db->clj get-conn execute! limited-companies] :as u]
            [auto-ap.entities.companies :as entity]
            [clojure.edn :as edn]
            [clojure.java.jdbc :as j]
            [honeysql.core :as sql]
            [honeysql.helpers :as helpers]))

(def base-query (sql/build :select :*
                           :from :checks))

(defn data->fields [x]
  (-> x
      (merge (:data x))
      (dissoc :data)))

(defn query [q]
  (map data->fields (u/query q)))

(defn get-all []
  (query base-query))

(defn get-by-id [id]
  (first (query (-> base-query
                    (helpers/merge-where [:= :id id])))))

(defn fields->data [x]
  (-> x
      (assoc-in [:data :pdf-data] (:pdf-data x))
      (assoc-in [:data :invoices] (:invoices x))
      (dissoc :pdf-data)
      (dissoc :invoices)))

(defn insert! [row]
  (-> (j/insert! (get-conn)
                 :checks
                 (-> row
                     fields->data
                     clj->db))
      first
      db->clj
      data->fields))

(defn insert-multi! [rows]
  (->> (j/insert-multi! (get-conn)
                        :checks
                        (->> rows
                             (map fields->data)
                             (map clj->db)))
       (map db->clj)
       (map data->fields)))

(def all-keys #{:company-id :vendor-id :id :status :date :s3-uuid :s3-key :s3-url :check-number :memo :amount :paid-to :bank-account-id :type})

(defn add-sort-by [q sort-by asc]
  (let [sort-by-key (keyword sort-by)]
    (cond (nil? sort-by)
          (helpers/merge-order-by q [:date])

          (= :date sort-by-key)
          (helpers/merge-order-by q [:date (when-not asc :desc)])

          (all-keys  sort-by-key)
          (helpers/merge-order-by q
                                  [sort-by-key (when-not asc :desc)]
                                  [:date])

          (= :vendor sort-by-key)
          (-> q
              (helpers/merge-left-join [:vendors :v] [:= :v.id :checks.vendor-id] )
              (helpers/merge-order-by [:v.name (when-not asc :desc)]
                                      [:date]))

          (= :company sort-by-key)
          (-> q
              (helpers/merge-left-join [:companies :c] [:= :c.id :checks.company-id] )
              (helpers/merge-order-by [:c.name (when-not asc :desc)]
                                      [:date]))

          :else
          q)))

(defn base-graphql [{:keys [company-id vendor-id check-number bank-account-id status amount id statuses]}]

  (cond-> base-query
    (limited-companies id) (helpers/merge-where [:in :company-id (limited-companies id)])
    (not (nil? company-id)) (helpers/merge-where [:= :company-id company-id])
    (not (nil? bank-account-id)) (helpers/merge-where [:= :bank-account-id bank-account-id])
    (not (nil? vendor-id)) (helpers/merge-where [:= :vendor-id vendor-id])
    (not (nil? check-number)) (helpers/merge-where [:= :check-number check-number])
    (not (nil? status)) (helpers/merge-where [:= :status status])
    (not (nil? amount)) (helpers/merge-where [:= :amount amount])
    (seq statuses ) (helpers/merge-where [:in :status statuses])))

(defn get-graphql [{:keys [start sort-by asc id limit] :as args :or {limit 20}}]
  (query
   (cond-> (base-graphql args)
     true (add-sort-by sort-by asc)
     true (assoc :limit limit)
     start (assoc :offset start))))

(defn count-graphql [args]
  (:count (first (query
                  (assoc (base-graphql args) :select [:%count.*])))))

(defn update! [row]
  (j/update! (get-conn)
             :checks
             (-> row (fields->data) (clj->db))
             ["id = ?" (:id row)]))