(ns auto-ap.integration.graphql.accounts
  (:require
   [auto-ap.datomic :refer [conn]]
   [auto-ap.graphql.accounts :as sut]
   [auto-ap.integration.util :refer [admin-token user-token wrap-setup]]
   [datomic.client.api :as dc]
   [clojure.test :as t :refer [deftest is testing use-fixtures]]))

(use-fixtures :each wrap-setup)

(deftest test-account-search
  (testing "It should find matching account names"
    (dc/transact conn {:tx-data [{:account/name              "Food Research"
                                  :db/ident                  :client-specific-account
                                  :account/numeric-code      51100
                                  :account/search-terms      "Food Research"
                                  :account/applicability     :account-applicability/global
                                  :account/default-allowance :allowance/allowed}]})
    (sut/rebuild-search-index)
    (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 "51100"}
                              nil
                              ))
           1)))
  (testing "It should filter out accounts that are not allowed for clients"
    (dc/transact conn {:tx-data [{: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}]})
    (sut/rebuild-search-index)
    (is (= [] (sut/search {:id (admin-token)}
                         {:query "CLIENTSPECIFIC"}
                         nil
                         )))
    
    (testing "It should show up for the client specific version"
      (let [client-id (-> (dc/transact conn {:tx-data [{: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"))]
        (sut/rebuild-search-index)
        (is (= 1 (count (sut/search {:id (admin-token)}
                                    {:query "HELLOWORLD"
                                     :client_id client-id}
                                    nil))))))

    (testing "It should hide accounts that arent applicable"
      (dc/transact conn {:tx-data [{: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"
      (dc/transact conn {:tx-data [{: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}]})
      (sut/rebuild-search-index)
      (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"
      (dc/transact conn {:tx-data [{: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}]})
      (sut/rebuild-search-index)
      (is (= 1 (count (sut/search {:id (admin-token)}
                                  {:query "ADMINONLY"}
                                  nil))))
      (is (= 0 (count (sut/search {:id (user-token)}
                                  {:query "ADMINONLY"}
                                  nil)))))

    (testing "It should allow searching for vendor accounts for invoices"
      (let [vendor-id (-> (dc/transact conn {:tx-data
                                             [{: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"))]
        (sut/rebuild-search-index)
        (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))))))))