(ns auto-ap.integration.graphql.accounts
  (:require
   [auto-ap.datomic :refer [conn uri]]
   [auto-ap.datomic.migrate :as m]
   [auto-ap.graphql.accounts :as sut]
   [clj-time.core :as time]
   [clojure.test :as t :refer [deftest is testing use-fixtures]]
   [datomic.api :as d]))

(defn wrap-setup
  [f]
  (with-redefs [auto-ap.datomic/uri "datomic:mem://datomic-transactor:4334/invoice"]
    (d/create-database uri)
    (with-redefs [auto-ap.datomic/conn (d/connect uri)]
      (m/migrate conn)
      @(d/transact conn (->> (d/q '[:find ?a
                              :where [?a :account/name]]
                                  (d/db conn))
                       (map (fn [[a]]
                              {:db/id a
                               :account/applicability :account-applicability/global}))))
      (f)
      (d/release conn)
      (d/delete-database uri))))    

#_{:clj-kondo/ignore [:clojure-lsp/unused-public-var]}
(defn admin-token []
  {:user "TEST ADMIN"
   :exp (time/plus (time/now) (time/days 1))
   :user/role "admin"
   :user/name "TEST ADMIN"})

#_{:clj-kondo/ignore [:clojure-lsp/unused-public-var]}
(defn user-token [client-id]
  {:user "TEST USER"
   :exp (time/plus (time/now) (time/days 1))
   :user/role "user"
   :user/name "TEST USER"
   :user/clients [{:db/id client-id}]})


(use-fixtures :each wrap-setup)

(deftest test-account-search
  (testing "It should find matching account names"
    (is (> (count (sut/search {:id (admin-token)}
                              {:query "Food Research"}
                              nil
                              ))
           0)))
  (testing "It should find exact matches by numbers"
    (is (= (count (sut/search {:id (admin-token)}
                              {:query "5110"}
                              nil
                              ))
           1)))
  (testing "It should filter out accounts that are not allowed for clients"
    @(d/transact conn [{:account/name              "CLIENT SPECIFIC"
                        :db/ident                  :client-specific-account
                        :account/numeric-code      99999
                        :account/search-terms      "CLIENTSPECIFIC"
                        :account/applicability     :account-applicability/customized
                        :account/default-allowance :allowance/allowed}])
    (is (= 0 (count (sut/search {:id (admin-token)}
                                {:query "CLIENTSPECIFIC"}
                                nil
                                ))))
    
    (testing "It should show up for the client specific version"
      (let [client-id (-> @(d/transact conn [{:client/name "CLIENT"
                                              :db/id       "client"}
                                             {:db/ident                 :client-specific-account
                                              :account/client-overrides [{:account-client-override/client       "client"
                                                                          :account-client-override/name         "HI"
                                                                          :account-client-override/search-terms "HELLOWORLD"}]}])
                          :tempids
                          (get "client"))]
        (is (= 1 (count (sut/search {:id (admin-token)}
                                    {:query "HELLOWORLD"
                                     :client_id client-id}
                                    nil))))))

    (testing "It should hide accounts that arent applicable"
      @(d/transact conn [{:account/name              "DENIED"
                          :db/ident                  :denied-account
                          :account/numeric-code      99998
                          :account/search-terms      "DENIED"
                          :account/applicability     :account-applicability/global
                          :account/default-allowance :allowance/denied
                          :account/vendor-allowance :allowance/denied
                          :account/invoice-allowance :allowance/denied}])
      (is (= 0 (count (sut/search {:id (admin-token)}
                                  {:query "DENIED"}
                                  nil))))
      (is (= 0 (count (sut/search {:id (admin-token)}
                                  {:query "DENIED"
                                   :allowance :invoice}
                                  nil))))
      (is (= 0 (count (sut/search {:id (admin-token)}
                                  {:query "DENIED"
                                   :allowance :vendor}
                                  nil)))))

    (testing "It should warn when using a warn account"
      @(d/transact conn [{:account/name              "WARNING"
                          :db/ident                  :warn-account
                          :account/numeric-code      99997
                          :account/search-terms      "WARNING"
                          :account/applicability     :account-applicability/global
                          :account/default-allowance :allowance/warn
                          :account/vendor-allowance :allowance/warn
                          :account/invoice-allowance :allowance/warn}])
      (is (some? (:warning (first (sut/search {:id (admin-token)}
                                              {:query     "WARNING"
                                               :allowance :global}
                                              nil)))))
      (is (some? (:warning (first (sut/search {:id (admin-token)}
                                              {:query     "WARNING"
                                               :allowance :invoice}
                                              nil)))))
      (is (some? (:warning (first (sut/search {:id (admin-token)}
                                              {:query     "WARNING"
                                               :allowance :vendor}
                                              nil))))))
    (testing "It should only include admin accounts for admins"
      @(d/transact conn [{:account/name              "ADMINONLY"
                          :db/ident                  :warn-account
                          :account/numeric-code      99997
                          :account/search-terms      "ADMINONLY"
                          :account/applicability     :account-applicability/global
                          :account/default-allowance :allowance/admin-only
                          :account/vendor-allowance :allowance/admin-only
                          :account/invoice-allowance :allowance/admin-only}])
      (is (= 1 (count (sut/search {:id (admin-token)}
                                  {:query "ADMINONLY"}
                                  nil))))
      (is (= 0 (count (sut/search {:id (user-token 1)}
                                  {:query "ADMINONLY"}
                                  nil)))))

    (testing "It should allow searching for vendor accounts for invoices"
      (let [vendor-id (-> @(d/transact conn [{:account/name              "VENDORONLY"
                                                :db/id "vendor-only"
                                                :db/ident                  :vendor-only
                                                :account/numeric-code      99996
                                                :account/search-terms      "VENDORONLY"
                                                :account/applicability     :account-applicability/global
                                                :account/default-allowance :allowance/allowed
                                                :account/vendor-allowance  :allowance/allowed
                                                :account/invoice-allowance :allowance/denied}
                                               {:vendor/name                    "Allowed"
                                                :vendor/default-account "vendor-only"
                                                :db/id                          "vendor"}])
                            :tempids
                            (get "vendor"))]
        (is (= 0 (count (sut/search {:id (admin-token)}
                                    {:query     "VENDORONLY"
                                     :allowance :invoice}
                                    nil))))

        (is (= 1 (count (sut/search {:id (admin-token)}
                                    {:query     "VENDORONLY"
                                     :allowance :invoice
                                     :vendor_id vendor-id}
                                    nil))))))))