(ns auto-ap.ssr.admin.vendors-test
  (:require
   [auto-ap.datomic :refer [conn]]
   [auto-ap.integration.util :refer [admin-token
                                     setup-test-data
                                     test-account
                                     test-client
                                     test-vendor
                                     user-token
                                     wrap-setup]]
   [auto-ap.ssr.admin.vendors :as sut]
   [clojure.string :as str]
   [clojure.test :refer [deftest is testing use-fixtures]]
   [datomic.api :as dc]))

(use-fixtures :each wrap-setup)

(defn create-vendor
  [name & {:as attrs}]
  (merge
   {:db/id (str "vendor-" (java.util.UUID/randomUUID))
    :vendor/name name
    :vendor/default-account "test-account-id"}
   attrs))

(deftest vendor-grid-loads-with-empty-database
  (testing "Vendor grid should handle empty database gracefully"
    (let [[vendors matching-count] (sut/fetch-page {:query-params {:page 1 :per-page 10}})]
      (is (seq? vendors))
      (is (number? matching-count))
      (is (= 0 (count vendors))))))

(deftest vendor-fetch-ids-returns-correct-structure
  (testing "fetch-ids should return properly structured results"
    (setup-test-data [(create-vendor "Test Vendor 1")
                      (create-vendor "Test Vendor 2")])
    (let [db (dc/db conn)
          result (sut/fetch-ids db {:query-params {:page 1 :per-page 10}})]
      (is (contains? result :ids))
      (is (contains? result :count))
      (is (seq? (:ids result)))
      (is (number? (:count result)))
      (is (>= (:count result) 3)))))

(deftest vendor-fetch-page-returns-vendors
  (testing "fetch-page should return vendors with proper structure"
    (setup-test-data [(create-vendor "Page Test Vendor 1")
                      (create-vendor "Page Test Vendor 2")])
    (let [[vendors matching-count] (sut/fetch-page {:query-params {:page 1 :per-page 10}})]
      (is (number? matching-count))
      (is (>= matching-count 3))
      (when-some [vendor (first vendors)]
        (is (contains? vendor :db/id))
        (is (contains? vendor :vendor/name))
        (is (contains? vendor :vendor/default-account))))))

(deftest vendor-hydrate-results-works
  (testing "hydrate-results should properly hydrate vendor data"
    (let [vendor-temp-id (str "vendor-" (rand-int 100000))
          tempids (setup-test-data [(assoc (create-vendor "Hydrate Test Vendor")
                                           :db/id vendor-temp-id)])
          db (dc/db conn)
          vendor-id (get tempids vendor-temp-id)
          hydrated (sut/hydrate-results [vendor-id] db {})]
      (is (= 1 (count hydrated)))
      (let [vendor (first hydrated)]
        (is (= vendor-id (:db/id vendor)))
        (is (= "Hydrate Test Vendor" (:vendor/name vendor)))
        (is (contains? vendor :vendor/default-account))))))

(deftest vendor-merge-transfers-references
  (testing "Vendor merge should transfer all references from source to target"
    (let [admin-identity (admin-token)
          source-temp-id (str "vendor-source-" (rand-int 100000))
          target-temp-id (str "vendor-target-" (rand-int 100000))
          tempids (setup-test-data [(assoc (create-vendor "Source Vendor")
                                           :db/id source-temp-id)
                                    (assoc (create-vendor "Target Vendor")
                                           :db/id target-temp-id)])
          source-vendor-id (get tempids source-temp-id)
          target-vendor-id (get tempids target-temp-id)
          result (sut/merge-submit {:form-params {:source-vendor source-vendor-id
                                                  :target-vendor target-vendor-id}
                                    :request-method :put
                                    :identity admin-identity})]
      (is (= 200 (:status result)))
      (let [db (dc/db conn)
            remaining-sources (dc/q '[:find ?e
                                      :where [?e :vendor/name "Source Vendor"]]
                                    db)]
        (is (= 0 (count remaining-sources)))))))

(deftest vendor-merge-same-vendor-rejected
  (testing "Vendor merge should reject when source and target are the same"
    (let [admin-identity (admin-token)
          vendor-temp-id (str "vendor-solo-" (rand-int 100000))
          tempids (setup-test-data [(assoc (create-vendor "Solo Vendor")
                                           :db/id vendor-temp-id)])
          vendor-id (get tempids vendor-temp-id)]
      (is (thrown-with-msg? clojure.lang.ExceptionInfo
                            #"Please select two different vendors"
                            (sut/merge-submit {:form-params {:source-vendor vendor-id
                                                             :target-vendor vendor-id}
                                               :request-method :put
                                               :identity admin-identity}))))))

(deftest vendor-merge-invalid-vendor-handled
  (testing "Vendor merge should handle invalid vendor IDs gracefully"
    (let [admin-identity (admin-token)
          target-temp-id (str "vendor-target-" (rand-int 100000))
          tempids (setup-test-data [(assoc (create-vendor "Valid Target Vendor")
                                           :db/id target-temp-id)])
          target-vendor-id (get tempids target-temp-id)
          invalid-source-id 999999999
          result (sut/merge-submit {:form-params {:source-vendor invalid-source-id
                                                  :target-vendor target-vendor-id}
                                    :request-method :put
                                    :identity admin-identity})]
      (is (= 200 (:status result))))))

(deftest vendor-hydration-includes-all-fields
  (testing "Vendor hydration should include all required fields"
    (let [vendor-temp-id (str "vendor-complete-" (rand-int 100000))
          tempids (setup-test-data [(assoc (create-vendor "Complete Vendor"
                                                          :vendor/print-as "CV Print Name"
                                                          :vendor/hidden false
                                                          :vendor/terms 30)
                                           :db/id vendor-temp-id)])
          db (dc/db conn)
          vendor-id (get tempids vendor-temp-id)
          hydrated (sut/hydrate-results [vendor-id] db {})
          vendor (first hydrated)]
      (is (some? vendor))
      (is (= "Complete Vendor" (:vendor/name vendor)))
      (is (= "CV Print Name" (:vendor/print-as vendor)))
      (is (= false (:vendor/hidden vendor)))
      (is (= 30 (:vendor/terms vendor))))))