(ns auto-ap.graphql.vendors
  (:require [auto-ap.graphql.utils :refer [->graphql assert-can-see-client assert-admin is-admin?]]
            [auto-ap.datomic.vendors :as d-vendors]
            [auto-ap.time :refer [parse iso-date]]
            [datomic.api :as d]
            [auto-ap.datomic :refer [uri remove-nils audit-transact conn]]
            [clj-time.coerce :as coerce]
            [clojure.set :as set]
            [clojure.tools.logging :as log]))


(defn upsert-vendor [context {{:keys [id name hidden terms code print_as primary_contact secondary_contact address default_account_id invoice_reminder_schedule schedule_payment_dom terms_overrides account_overrides] :as in} :vendor} value]
  (when id
    (assert-admin (:id context)))
  #_(Thread/sleep 3000)
  #_(throw (ex-info "" {:validation-error "can't do that."}))
  (let [hidden (if (is-admin? (:id context))
                 hidden
                 false)

        terms-overrides (mapv
                        (fn [to]
                          (cond-> 
                              #:vendor-terms-override {:client (:client_id to)
                                                       :terms (:terms to)}
                              (:id to) (assoc :db/id (:id to))))
                        terms_overrides)
        account-overrides (mapv
                           (fn [ao]
                             (cond-> 
                                 #:vendor-account-override {:client (:client_id ao)
                                                            :account (:account_id ao)}
                                 (:id ao) (assoc :db/id (:id ao))))
                           account_overrides)
        schedule-payment-dom (mapv
                           (fn [ao]
                             (cond-> 
                                 #:vendor-schedule-payment-dom {:client (:client_id ao)
                                                                :dom (:dom ao)}
                               (:id ao) (assoc :db/id (:id ao))))
                           schedule_payment_dom)
        transaction (cond-> 
                        [(remove-nils #:vendor {:db/id (if id
                                                         id
                                                         "vendor")
                                                :name name
                                                :code code
                                                :hidden hidden
                                                :terms terms
                                                :print-as print_as
                                                :default-account default_account_id
                                                :invoice-reminder-schedule (keyword invoice_reminder_schedule)
                                                
                                                
                                                :address (when address
                                                           (remove-nils #:address {:db/id (if (:id address)
                                                                                            (:id address)
                                                                                            "address")
                                                                                   :street1 (:street1 address)
                                                                                   :street2 (:street2 address)
                                                                                   :city (:city address)
                                                                                   :state (:state address)
                                                                                   :zip (:zip address)}))
                                                :primary-contact (when primary_contact

                                                                   (remove-nils #:contact {:db/id (if (:id primary_contact)
                                                                                                    (:id primary_contact)
                                                                                                    "primary")
                                                                                           :name (:name primary_contact)
                                                                                           :phone (:phone primary_contact)
                                                                                           :email (:email primary_contact)}))
                                                
                                                :secondary-contact (when secondary_contact

                                                                     (remove-nils #:contact {:db/id (if (:id secondary_contact)
                                                                                                      (:id secondary_contact)
                                                                                                      "secondary")
                                                                                             :name (:name secondary_contact)
                                                                                             :phone (:phone secondary_contact)
                                                                                             :email (:email secondary_contact)})
                                                                     )})]
                        (is-admin? (:id context)) (conj [:reset (if id id "vendor") :vendor/account-overrides account-overrides])
                        (is-admin? (:id context)) (conj [:reset (if id id "vendor") :vendor/terms-overrides terms-overrides])
                        (is-admin? (:id context)) (conj [:reset (if id id "vendor") :vendor/schedule-payment-dom schedule-payment-dom])
                        (is-admin? (:id context)) (conj [:reset (if id id "vendor") :vendor/automatically-paid-when-due
                                                         (mapv
                                                          (fn [apwd]
                                                            {:db/id apwd})
                                                          (:automatically_paid_when_due in))]))

        _ (log/info "Upserting vendor" transaction)
        transaction-result (audit-transact transaction (:id context))]
    
    (-> (d-vendors/get-by-id (or (-> transaction-result :tempids (get "vendor"))
                                 id))
        (->graphql))))

(defn merge-vendors [context {:keys [from to]} value]
  (let [transaction (->> (d/query {:query {:find '[?x ?a2]
                                           :in '[$ ?vendor-from ]
                                           :where ['[?x ?a ?vendor-from]
                                                   '[?a :db/ident ?a2]]}
                                   :args [(d/db conn) from]})
                         (mapcat (fn [[src attr]]

                                   [[:db/retract src attr from]
                                    [:db/add src attr to]])))
        transaction (conj transaction [:db/retractEntity from])]
    (audit-transact transaction (:id context))
    to))

(defn get-graphql [context args value]
  (->graphql
   (d-vendors/get-graphql (assoc args :id (:id context)))))