(ns net.deertopia.doerg.roam-test
  (:require [net.deertopia.doerg.roam :as sut]
            [clojure.test :as t]
            [clojure.java.io :as io]
            [net.deertopia.doerg.config :as cfg]
            [babashka.fs :as fs]
            [babashka.process :as p]
            [net.deertopia.doerg.config-test :refer [test-config-fixture]]
            [next.jdbc :as sql]
            [clojure.string :as str]
            [net.deertopia.doerg.elisp :as elisp]
            [com.rpl.specter :as sp]))

(def org-roam-directory
  (fs/file "test/net/deertopia/doerg/roam-test"))

(defn org-roam-db-sync [db-file]
  (let [script-file (fs/create-temp-file {:prefix "org-roam-db-sync-"
                                          :suffix ".el"})
        emacs (->> [(System/getenv "EMACS") "test-emacs" "emacs"]
                   (some #(some-> % fs/which)))]
    (io/copy (-> "net/deertopia/doerg/org-roam-db-sync.el"
                 io/resource io/reader)
             (fs/file script-file))
    (p/shell {:out :string :err :string}
             emacs "-Q" "-x" script-file org-roam-directory db-file)
    (fs/delete script-file)))

(defn test-db-fixture [f]
  (let [db-file (-> cfg/*cfg* ::cfg/org-roam-db-path)]
    (assert (->> db-file fs/canonicalize str
                 (re-matches #"^/(build|tmp)/.*"))
            (format "i'm scared to delete a non-test database... %s"
                    (str db-file)))
    (fs/delete-if-exists db-file)
    (org-roam-db-sync db-file)
    (f)
    (fs/delete db-file)))

(t/use-fixtures
  :once (t/join-fixtures [test-config-fixture test-db-fixture]))



(t/deftest all-nodes-exist
  (let [known-node-files (->> (fs/list-dir org-roam-directory)
                              (map (comp str fs/canonicalize))
                              (into #{}))
        database-nodes
        (->> (sql/execute!
              (sut/ds) ["select file, id from nodes"])
             (map (fn [x]
                    {:file (-> x :nodes/file elisp/read-string)
                     :id (-> x :nodes/id elisp/read-string parse-uuid)}))
             (into #{}))]
    (t/testing "database has a node for each file?"
      (t/is (= known-node-files (sp/transform
                                 [sp/ALL]
                                 #(:file %)
                                 database-nodes))))
    (t/testing "each uuid exists?"
      (t/is (every? (comp sut/uuid-exists? :id)
                    database-nodes)))))