(ns auto-ap.datomic.transaction-rules
  (:require [datomic.api :as d]
            [auto-ap.datomic :refer [uri merge-query apply-sort-3 apply-pagination add-sorter-fields]]
            [auto-ap.graphql.utils :refer [limited-clients]]
            [clojure.set :refer [rename-keys]]
            [clj-time.coerce :as c]
            [clojure.string :as str]))

(defn <-datomic [result]
  result)

(def default-read '[*
                    {:transaction-rule/client [:client/name :db/id :client/code]}
                    {:transaction-rule/bank-account [*]}
                    {:transaction-rule/yodlee-merchant [:db/id :yodlee-merchant/name :yodlee-merchant/yodlee-id]}
                    {:transaction-rule/transaction-approval-status [:db/id :db/ident]}
                    {:transaction-rule/vendor [:vendor/name :db/id :vendor/default-account]}
                    {:transaction-rule/accounts [:transaction-rule-account/percentage
                                                 :transaction-rule-account/location
                                                 {:transaction-rule-account/account [*]}
                                                 :db/id]}])

(defn raw-graphql-ids [db args]
  (let [query (cond-> {:query {:find []
                               :in ['$]
                               :where []}
                       :args [db]}
                (:sort args) (add-sorter-fields {"client" ['[?e :transaction-rule/client ?c]
                                                           '[?c :client/name ?sort-client]]

                                                 "yodlee-merchant" ['[?e :transaction-rule/yodlee-merchant ?ym]
                                                                    '[?ym :yodlee-merchant/name ?sort-yodlee-merchant]]
                                                 "bank-account" ['[?e :transaction-rule/bank-account ?ba]
                                                                 '[?ba :bank-account/name ?sort-bank-account]]
                                                 "description" ['[?e :transaction-rule/description ?sort-description]]
                                                 "note" ['[?e :transaction-rule/note ?sort-note]]
                                                 "amount-lte" ['[?e :transaction-rule/amount-lte ?sort-amount-lte]]
                                                 "amount-gte" ['[?e :transaction-rule/amount-gte ?sort-amount-gte]]}
                                                  args)

                (limited-clients (:id args))
                (merge-query {:query {:in ['[?xx ...]]
                                      :where ['[?e :transaction-rule/client ?xx]]}
                              :args [(set (map :db/id (limited-clients (:id args))))]})

                (:client-id args)
                (merge-query {:query {:in ['?client-id]
                                      :where ['[?e :transaction-rule/client ?client-id]]}
                              :args [(:client-id args)]})

                (:vendor-id args)
                (merge-query {:query {:in ['?vendor-id]
                                      :where ['[?e :transaction-rule/vendor ?vendor-id]]}
                              :args [(:vendor-id args)]})

                (not (str/blank? (:note args)))
                (merge-query {:query {:in ['?note-pattern]
                                      :where ['[?e :transaction-rule/note ?n]
                                              '[(re-find ?note-pattern ?n)]]}
                              :args [(re-pattern (str "(?i)" (:note args)))]})

                true
                (merge-query {:query {:find ['?e]
                                      :where ['[?e :transaction-rule/transaction-approval-status]]}}))]

    
    (cond->> query
      true (d/query)
      true (apply-sort-3 args)
      true (apply-pagination args))))

(defn graphql-results [ids db args]
  (let [results (->> (d/pull-many db default-read ids)
                     (group-by :db/id))
        transaction-rules (->> ids
                               (map results)
                               (map first)
                               (mapv <-datomic))]
    transaction-rules))

(defn get-graphql [args]
  (let [db (d/db (d/connect uri))
        {ids-to-retrieve :ids matching-count :count} (raw-graphql-ids db args)]
    [(->> (graphql-results ids-to-retrieve db args))
     matching-count]))

(defn get-by-id [id]
  (->> 
   (d/pull (d/db (d/connect uri)) default-read id)
   (<-datomic)))

(defn get-all []
  (mapv first
        (d/query {:query {:find [(list 'pull '?e default-read )]
                          :in ['$]
                          :where ['[?e :transaction-rule/transaction-approval-status]]}
                  :args [(d/db (d/connect uri))]})))