(ns auto-ap.import.transactions-test
  (:require
   [auto-ap.datomic :refer [conn]]
   [auto-ap.import.transactions :as sut]
   [auto-ap.integration.util :refer [setup-test-data wrap-setup]]
   [clj-time.coerce :as coerce]
   [clojure.test :as t]
   [datomic.api :as dc]
   [digest :as di]))

(t/use-fixtures :each wrap-setup)

(defn noop-rule [transaction _]
  transaction)

(def base-transaction #:transaction {:date #inst "2020-01-02T00:00:00-08:00"
                                     :raw-id "1"
                                     :id (di/sha-256 "1")
                                     :amount 12.0
                                     :description-original  "original-description"
                                     :status "POSTED"
                                     :client 123
                                     :bank-account 456})

(t/deftest categorize-transactions
  (let [bank-account {:db/id 456
                      :client/_bank-accounts {:db/id 123
                                              :client/locations ["MH"]}}]
    (t/testing "Should exclude a transaction before start date"
      (t/is (= :not-ready
               (sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-01")
                                           (assoc bank-account :bank-account/start-date #inst "2030-01-01")
                                           {})))
      (t/is (= :import
               (sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-02")
                                           (assoc bank-account :bank-account/start-date #inst "2020-01-01")
                                           {}))))
    (t/testing "Should exclude a transaction before locked-until"
      (t/is (= :not-ready
               (sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-01")
                                           (assoc-in bank-account [:client/_bank-accounts :client/locked-until] #inst "2030-01-01")
                                           {})))
      (t/is (= :import
               (sut/categorize-transaction (assoc base-transaction :transaction/date #inst "2020-01-01")
                                           (assoc-in bank-account [:client/_bank-accounts :client/locked-until] #inst "2010-01-01")
                                           {}))))
    (t/testing "Should error a transaction without a client"
      (t/is (= :error
               (sut/categorize-transaction (dissoc base-transaction :transaction/client)
                                           bank-account
                                           {}))))

    (t/testing "Should error a transaction without a bank-account"
      (t/is (= :error
               (sut/categorize-transaction (dissoc base-transaction :transaction/bank-account)
                                           bank-account
                                           {}))))
    (t/testing "Should error a transaction without an id"
      (t/is (= :error
               (sut/categorize-transaction (dissoc base-transaction :transaction/id)
                                           bank-account
                                           {}))))
    (t/testing "Should ignore a transaction that exists"
      (t/is (= :extant
               (sut/categorize-transaction (assoc base-transaction :transaction/id "123")
                                           bank-account
                                           {"123" :transaction-approval-status/unapproved}))))
    (t/testing "Should import a transaction"
      (t/is (= :import
               (sut/categorize-transaction base-transaction
                                           bank-account
                                           {}))))))


(t/deftest transaction->txs
  (t/testing "Should import and code transactions"
    (t/testing "Should import one transaction"
      (let [{:strs [bank-account-id client-id]} (:tempids @(dc/transact conn
                                                                        [{:db/id             "bank-account-id"
                                                                          :bank-account/code "TEST-1"}
                                                                         {:db/id                "client-id"
                                                                          :client/code          "TEST"
                                                                          :client/locations     ["Z" "E"]
                                                                          :client/bank-accounts ["bank-account-id"]}]))
            result                              (sut/transaction->txs base-transaction
                                         (dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
                                         noop-rule)]
        (t/is (= (assoc base-transaction
                        :transaction/approval-status :transaction-approval-status/unapproved
                        :transaction/bank-account bank-account-id
                        :transaction/client client-id)
                 result))))

    (t/testing "Should apply a default vendor"
      (let [ {:strs [test-client-id test-bank-account-id test-vendor-id]} (setup-test-data [])
            result                                                        (sut/transaction->txs (assoc base-transaction
                                                                                                       :transaction/default-vendor test-vendor-id)
                                                                      (dc/pull (dc/db conn) sut/bank-account-pull test-bank-account-id)
                                                                      noop-rule)]
        (t/is (= (assoc base-transaction
                        :transaction/approval-status :transaction-approval-status/unapproved
                        :transaction/bank-account test-bank-account-id
                        :transaction/vendor test-vendor-id
                        :transaction/client test-client-id)
                 result))))

    (t/testing "Should match an uncleared check"
      (let [{:strs [bank-account-id payment-id]} (->> [#:payment {:status       :payment-status/pending
                                                                  :date         #inst "2019-01-01"
                                                                  :bank-account "bank-account-id"
                                                                  :client       "client-id"
                                                                  :check-number 10001
                                                                  :amount       30.0
                                                                  :db/id        "payment-id"}
                                                       #:bank-account {:name  "Bank account"
                                                                       :db/id "bank-account-id"}
                                                       #:client {:name          "Client"
                                                                 :db/id         "client-id"
                                                                 :bank-accounts ["bank-account-id"]}]
                                                      (dc/transact conn)
                                                      deref
                                                      :tempids)]

        (let [transaction-result (sut/transaction->txs (assoc base-transaction
                                                              :transaction/description-original "CHECK 10001"
                                                              :transaction/check-number 10001
                                                              :transaction/amount -30.0)
                                                       (dc/pull (dc/db conn ) sut/bank-account-pull bank-account-id)
                                                       noop-rule)]
          
          (t/is (= {:db/id          payment-id
                    :payment/status :payment-status/cleared}
                   (:transaction/payment transaction-result))))


        (t/testing "Should match a check that matches on amount if check number does not match"
          (let [transaction-result (sut/transaction->txs (assoc base-transaction
                                                                :transaction/description-original "CHECK 12301"
                                                                :transaction/amount -30.0)
                                                         (dc/pull (dc/db conn ) sut/bank-account-pull bank-account-id)
                                                         noop-rule)]
            
            (t/is (= {:db/id          payment-id
                      :payment/status :payment-status/cleared}
                     (:transaction/payment transaction-result)))))

        (t/testing "Should not match an already matched check"
          @(dc/transact conn [{:db/id payment-id :payment/status :payment-status/cleared}])
          (let [result (sut/transaction->txs (assoc base-transaction
                                                    :transaction/description-original "CHECK 10001"
                                                    :transaction/amount -30.0)
                                             (dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
                                             noop-rule)]
            
            (t/is (= nil
                     (:transaction/payment result)))))))


    (t/testing "Should match expected-deposits"
      (let [{:strs [bank-account-id client-id expected-deposit-id]} (->> [#:expected-deposit {:client   "client-id"
                                                                                              :date     #inst "2021-07-01T00:00:00-08:00"
                                                                                              :vendor   :vendor/ccp-square
                                                                                              :total    100.0
                                                                                              :location "MF"
                                                                                              :status   :expected-deposit-status/pending
                                                                                              :db/id    "expected-deposit-id"}
                                                                          #:bank-account {:name  "Bank account"
                                                                                          :db/id "bank-account-id"}
                                                                          #:client {:name          "Client"
                                                                                    :db/id         "client-id"
                                                                                    :locations     ["MF"]
                                                                                    :bank-accounts ["bank-account-id"]}]
                                                                         (dc/transact conn)
                                                                         deref
                                                                         :tempids)]


        (t/testing "Should match within 10 days"
          (let [transaction-result (sut/transaction->txs (assoc base-transaction
                                                                :transaction/date #inst "2021-07-03T00:00:00-08:00"
                                                                :transaction/amount 100.0)
                                                         (dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
                                                         noop-rule)]
            (t/is (= expected-deposit-id
                     (:db/id (sut/find-expected-deposit client-id 100.0 (clj-time.coerce/to-date-time #inst "2021-07-03T00:00:00-08:00")))))
            
            (t/is (= {:db/id                   expected-deposit-id
                      :expected-deposit/status :expected-deposit-status/cleared}
                     (:transaction/expected-deposit transaction-result)))))

        (t/testing "Should copy vendor from expected-depoisit"
          (let [transaction-result (sut/transaction->txs (assoc base-transaction
                                                                :transaction/vendor :vendor/ccp-square)
                                                         (dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
                                                         noop-rule)]
            (t/is (= :vendor/ccp-square
                     (:transaction/vendor transaction-result))))) 

        (t/testing "Should credit CCP"
          (let [transaction-result (sut/transaction->txs (assoc base-transaction
                                                                :transaction/date #inst "2021-07-03T00:00:00-08:00"
                                                                :transaction/amount 100.0)
                                                         (dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
                                                         noop-rule)]
            (t/is (= [{:transaction-account/account  :account/ccp
                       :transaction-account/amount   100.0
                       :transaction-account/location "A"}]
                     (->> (:transaction/accounts transaction-result)
                          (map (fn [ta] (dissoc ta :db/id))))))))

        (t/testing "Should not match old expected deposits"
          (let [transaction-result (sut/transaction->txs (assoc base-transaction
                                                                :transaction/date #inst "2021-07-13"
                                                                :transaction/amount 100.0)
                                                         (dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
                                                         noop-rule)]
            (t/is (not (:transaction/expected-deposit transaction-result)))))

        (t/testing "Should only match exact."
          (let [transaction-result (sut/transaction->txs (assoc base-transaction
                                                                :transaction/date "2021-07-03"
                                                                :transaction/amount 100.01)
                                                         (dc/pull (dc/db conn) sut/bank-account-pull bank-account-id)
                                                         noop-rule)]
            (t/is (not (:transaction/expected-deposit transaction-result)))))))))

(t/deftest apply-synthetic-ids
  (t/testing "Should increment index for duplicate transactions"
    (t/is (= ["2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
              "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-1-123"]
             (map :transaction/raw-id (sut/apply-synthetic-ids [base-transaction base-transaction])))))

  (t/testing "Should use unique ids if a parameter is different"
    (t/is (= ["2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
              "2020-01-02T00:00:00.000-08:00-456-original-description-13.0-0-123"]
             (map :transaction/raw-id (sut/apply-synthetic-ids [base-transaction (assoc base-transaction :transaction/amount 13.0)])))))

  (t/testing "Should increment index if an unimportant field is set"
    (t/is (= ["2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
              "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-1-123"]
             (map :transaction/raw-id (sut/apply-synthetic-ids [base-transaction (assoc base-transaction :transaction/other-random-value 10.0)])))))

  (t/testing "Should be forgiving if dates come in other formats"
    (t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
             (->> (sut/apply-synthetic-ids [(assoc base-transaction
                                                   :transaction/date #inst "2020-01-02T00:00:00-08:00")])
                  first
                  :transaction/raw-id)))
    (t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
             (->> (sut/apply-synthetic-ids [(assoc base-transaction
                                                   :transaction/date #inst "2020-01-02T08:00:00-00:00")])
                  first
                  :transaction/raw-id)))
    (t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
             (->> (sut/apply-synthetic-ids [(assoc base-transaction
                                                   :transaction/date (coerce/to-date-time #inst "2020-01-02T08:00:00-00:00"))])
                  first
                  :transaction/raw-id)))
    (t/is (= "2020-01-02T00:00:00.000-08:00-456-original-description-12.0-0-123"
             (->> (sut/apply-synthetic-ids [(assoc base-transaction
                                                   :transaction/date (coerce/to-date-time #inst "2020-01-02T00:00:00-08:00"))])
                  first
                  :transaction/raw-id)))))


(t/deftest match-transaction-to-single-unfulfilled-payments
  (t/testing "Auto-pay Invoices"
    (let [{:strs [vendor1-id vendor2-id]} (->> [#:vendor {:name  "Autopay vendor 1"
                                                          :db/id "vendor1-id"}
                                                #:vendor {:name  "Autopay vendor 2"
                                                          :db/id "vendor2-id"}]
                                               (dc/transact conn)
                                               deref
                                               :tempids)]
      (t/testing "Should find a single invoice that matches exactly"
        (let [{:strs [client-id]} (->> [#:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             30.0
                                                   :db/id             "invoice-id"}
                                        #:client {:name "Client" :db/id "client-id"}]
                                                  (dc/transact conn)
                                                  deref
                                                  :tempids)
              invoices-matches (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
          (t/is (= 1 (count invoices-matches)))
          ))

      (t/testing "Should not match paid invoice that isn't a scheduled payment"
        (let [{:strs [client-id]} (->> [#:invoice{:status :invoice-status/paid
                                                  :vendor vendor1-id
                                                  :date   #inst "2019-01-01"
                                                  :client "client-id"
                                                  :total  30.0
                                                  :db/id  "invoice-id"}
                                        #:client {:name "Client" :db/id "client-id"}]
                                       (dc/transact conn)
                                       deref
                                       :tempids)
              invoices-matches    (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
          
          (t/is (= [] invoices-matches))))

      (t/testing "Should not match unpaid invoice"
        (let [{:strs [client-id]} (->> [#:invoice {:status            :invoice-status/unpaid
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :vendor            vendor1-id 
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             30.0
                                                   :db/id             "invoice-id"}
                                        #:client {:name "Client" :db/id "client-id"}]
                                       (dc/transact conn)
                                       deref
                                       :tempids)
              invoices-matches    (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
          
          (t/is (= [] invoices-matches))))

      (t/testing "Should not match invoice that already has a payment"
        (let [{:strs [client-id]} (->> [#:invoice {:status            :invoice-status/paid
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :vendor            vendor1-id
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             30.0
                                                   :db/id             "invoice-id"}
                                        {:invoice-payment/amount  30.0
                                         :invoice-payment/invoice "invoice-id"}
                                        #:client {:name  "Client"
                                                  :db/id "client-id"}]
                                       (dc/transact conn)
                                       deref
                                       :tempids)
              invoices-matches    (sut/match-transaction-to-single-unfulfilled-autopayments -30.0
                                                                                         client-id)]
          (t/is (= [] invoices-matches))))
      (t/testing "Should match multiple invoices for same vendor that total to transaction amount"
        (let [{:strs [client-id]} (->> [#:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             15.0
                                                   :db/id             "invoice1-id"}
                                        #:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             15.0
                                                   :db/id             "invoice2-id"}
                                        #:client {:name "Client" :db/id "client-id"}]
                                       (dc/transact conn)
                                       deref
                                       :tempids)
              invoices-matches    (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
          (t/is (= 2 (count invoices-matches))
                (str "Expected " (vec invoices-matches) " to have a singular match of two invoices."))))
      (t/testing "Should not match if there are multiple candidate matches"
        (let [{:strs [client-id]} (->> [#:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             30.0
                                                   :db/id             "invoice1-id"}
                                        #:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             30.0
                                                   :db/id             "invoice2-id"}
                                        #:client {:name "Client" :db/id "client-id"}]
                                       (dc/transact conn)
                                       deref
                                       :tempids)
              invoices-matches    (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
          (t/is (= 0 (count invoices-matches))
                (str "Expected " (vec invoices-matches) " to not match due to multiple possibilities."))))

      (t/testing "Should not match if invoices are for different vendors"
        (let [{:strs [client-id]} (->> [#:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             10.0
                                                   :db/id             "invoice1-id"}
                                        #:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor2-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             20.0
                                                   :db/id             "invoice2-id"}
                                        #:client {:name "Client" :db/id "client-id"}]
                                       (dc/transact conn)
                                       deref
                                       :tempids)
              invoices-matches    (sut/match-transaction-to-single-unfulfilled-autopayments -30.0 client-id)]
          (t/is (= 0 (count invoices-matches))
                (str "Expected " (vec invoices-matches) " to only consider invoices for the same vendor."))))

      (t/testing "Should only consider invoices chronologically"
        (let [{:strs [client-id]} (->> [#:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-04"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             10.0
                                                   :db/id             "invoice1-id"}
                                        #:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-06"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             21.0
                                                   :db/id             "invoice2-id"}
                                        #:invoice {:status            :invoice-status/paid
                                                   :vendor            vendor1-id
                                                   :scheduled-payment #inst "2019-01-05"
                                                   :date              #inst "2019-01-01"
                                                   :client            "client-id"
                                                   :total             30.0
                                                   :db/id             "invoice3-id"}
                                        #:client {:name "Client" :db/id "client-id"}]
                                       (dc/transact conn)
                                       deref
                                       :tempids)]
          (t/is (= 2 (count (sut/match-transaction-to-single-unfulfilled-autopayments -40.0 client-id)))
                (str "Expected  to match with the chronologically adjacent invoice-1 and invoice-3."))
          (t/is (= [] (sut/match-transaction-to-single-unfulfilled-autopayments -31.0 client-id))
                (str "Expected  to not match, because there is invoice-3 is between invoice-1 and invoice-2.")))))))





#_(t/testing "Auto-pay Invoices"
    (t/testing "Should match paid invoice that doesn't have a payment yet"
      (let [{:strs [bank-account-id client-id invoice1-id invoice2-id vendor-id]} (->> [#:invoice {:status :invoice-status/paid
                                                                                      :vendor "vendor-id"
                                                                                      :scheduled-payment #inst "2019-01-04"
                                                                                      :date #inst "2019-01-01"
                                                                                      :client "client-id"
                                                                                      :total 20.0
                                                                                      :db/id "invoice1-id"}
                                                                           #:invoice {:status :invoice-status/paid
                                                                                      :vendor "vendor-id"
                                                                                      :scheduled-payment #inst "2019-01-04"
                                                                                      :date #inst "2019-01-01"
                                                                                      :client "client-id"
                                                                                      :total 10.0
                                                                                      :db/id "invoice2-id"}
                                                                           #:vendor {:name "Autopay vendor"
                                                                                     :db/id "vendor-id"}
                                                                           #:bank-account {:name "Bank account"
                                                                                           :db/id "bank-account-id"}
                                                                           #:client {:name "Client"
                                                                                     :db/id "client-id"
                                                                                     :bank-accounts ["bank-account-id"]}]
                                                                          (d/transact (d/connect uri))
                                                                          deref
                                                                          :tempids)
            [[transaction-tx payment-tx invoice-payments1-tx invoice-payments2-tx]] (sut/yodlees->transactions [(assoc base-yodlee-transaction
                                                                         :amount {:amount 30.0}
                                                                         :bank-account {:db/id  bank-account-id
                                                                                        :client/_bank-accounts {:db/id client-id
                                                                                                                :client/locations ["A"]}})]
                                                                 :bank-account
                                                                 noop-rule
                                                                 #{})]
        
        (t/is (= :transaction-approval-status/approved
                 (:transaction/approval-status transaction-tx))
              (str "Should have approved transaction " transaction-tx))
        (t/is (=  #:payment{:status :payment-status/cleared
                            :type :payment-type/debit
                            :date (:transaction/date transaction-tx)
                            :client client-id
                            :bank-account bank-account-id
                            :vendor vendor-id
                            :amount 30.0}

                  (dissoc payment-tx :db/id))
              (str "Should have created payment " payment-tx))
        (t/is (=  #:invoice-payment{:invoice invoice1-id
                                    :amount 20.0
                                    :payment (:db/id payment-tx)}

                  (dissoc invoice-payments1-tx :db/id))
              (str "Should have paid invoice 1" invoice-payments1-tx))
        (t/is (=  #:invoice-payment{:invoice invoice2-id
                                    :amount 10.0
                                    :payment (:db/id payment-tx)}

                  (dissoc invoice-payments2-tx :db/id))
              (str "Should have paid invoice 2" invoice-payments2-tx))))

    (t/testing "Should not match paid invoice that isn't a scheduled payment"
      (let [{:strs [bank-account-id client-id invoice-id]} (->> [#:invoice {:status :invoice-status/paid
                                                                            :vendor "vendor-id"
                                                                            :date #inst "2019-01-01"
                                                                            :client "client-id"
                                                                            :total 30.0
                                                                            :db/id "invoice-id"}
                                                                 #:vendor {:name "Autopay vendor"
                                                                           :db/id "vendor-id"}
                                                                 #:bank-account {:name "Bank account"
                                                                                 :db/id "bank-account-id"}
                                                                 #:client {:name "Client"
                                                                           :db/id "client-id"
                                                                           :bank-accounts ["bank-account-id"]}]
                                                                (d/transact (d/connect uri))
                                                                deref
                                                                :tempids)
            [[transaction-tx payment-tx]] (sut/yodlees->transactions [(assoc base-yodlee-transaction
                                                                         :amount {:amount 30.0}
                                                                         :bank-account {:db/id  bank-account-id
                                                                                        :client/_bank-accounts {:db/id client-id
                                                                                                                :client/locations ["A"]}})]
                                                                 :bank-account
                                                                 noop-rule
                                                                 #{})]
        
        (t/is (= :transaction-approval-status/unapproved
                 (:transaction/approval-status transaction-tx)))
        (t/is (nil? (:transaction/payment transaction-tx))))))
