#_{:clj-kondo/ignore [:unused-namespace]}
(ns auto-ap.subs
  (:require [re-frame.core :as re-frame]
            [auto-ap.utils :refer [by]]
            [auto-ap.views.utils :refer [parse-jwt]]
            [clojure.string :as str]
            [goog.crypt.base64 :as base64]
            [minisearch :as ms]))
(set! *warn-on-infer* true)

#_{:clj-kondo/ignore [:unresolved-symbol]}
(def MiniSearch (if ms (aget ms "default")
                    nil))

(re-frame/reg-sub
 ::client
 (fn [db]
   (get (:clients db) (:client db))))

(re-frame/reg-sub
 ::clients
 (fn [db]
   (when (:user db)
     (sort-by :name (vals (:clients db))))))

(re-frame/reg-sub
  ::client-refs
  :<- [::clients]
  (fn [c]
    (map #(select-keys % [:id :name]) c)))

(re-frame/reg-sub
 ::all-accounts
 (fn [db]
   (:accounts db)))

(re-frame/reg-sub
 ::all-accounts-by-id
 (fn [db]
   (by :id (:accounts db))))

(re-frame/reg-sub
 ::bank-accounts
 :<- [::clients]
 :<- [::client]
 (fn [[clients client]]
   (if client
     (:bank-accounts client)
     (reduce (fn [result {:keys [bank-accounts]}]
               (into result bank-accounts))
             []
             clients))))

(re-frame/reg-sub
 ::bank-accounts-by-id
 :<- [::bank-accounts]
 (fn [as]
   (by :id as)))

;; Bank accounts only, not including cash
(re-frame/reg-sub
 ::real-bank-accounts 
 :<- [::client]
 (fn [client]
   (->> client :bank-accounts (filter #(= (:type %) :check)) (sort-by :sort-order))))

(re-frame/reg-sub
 ::real-bank-accounts-for-client
 (fn [db [_ {:keys [id]}]]
   (sort-by :sort-order (-> db :clients (get id) :bank-accounts ))))

(re-frame/reg-sub
 ::locations-for-client
 
 (fn [db [_ client]]
   (:locations (get (:clients db) (or client (:client db))))))

(re-frame/reg-sub
 ::forecasted-transactions-for-client
 (fn [db [_ client]]
   (:forecasted-transactions (get (:clients db) (or client (:client db))))))

(re-frame/reg-sub
 ::locations-for-client-or-bank-account
 (fn [db [_ client-id bank-account-id]]
   (let [client (get (:clients db) (or client-id (:client db)))
         client-locations (:locations client)
         bank-account-locations (-> (by :id (:bank-accounts client))
                                    (get bank-account-id)
                                    :locations)]
     (or (seq bank-account-locations) client-locations))))

(re-frame/reg-sub
 ::clients-by-id
 (fn [db]
   (when (:user db)
     (:clients db))))

(re-frame/reg-sub
 ::menu-active?
 (fn [db [_ id]]
   (-> db :menu (get id) :active?)))

(re-frame/reg-sub
 ::menu
 (fn [db]
   (:menu db)))

(re-frame/reg-sub
 ::is-initial-loading?
 (fn [db]
   (:is-initial-loading? db)))

(re-frame/reg-sub
 ::intuit-bank-accounts
 (fn [db]
   (::intuit-bank-accounts db)))

(re-frame/reg-sub
 ::token
 (fn [db]
   (:user db)))

(re-frame/reg-sub
 ::admin
 (fn [db]
   (:admin db)))

(re-frame/reg-sub
 ::is-admin?
 :<- [::user]
 (fn [user]
   (= "admin" (:user/role user))))

(re-frame/reg-sub
 ::is-power-user?
 :<- [::user]
 (fn [user]
   (or (= "power-user" (:user/role user))
       (= "power_user" (:user/role user)))))

(re-frame/reg-sub
 ::user
 (fn [db]
   (parse-jwt (:user db))))

(re-frame/reg-sub
  ::active-route
  (fn [db]
    (:active-route db)))

(re-frame/reg-sub
 ::active-page
 :<- [::active-route]
 (fn [route]
   (or ({:admin-specific-client :admin-clients
         :admin-specific-bank-account :admin-clients}
        route)
       route)))

(re-frame/reg-sub
 ::query-params
 (fn [db]
   (:query-params db)))

(re-frame/reg-sub
  ::route-params
  (fn [db]
    (:route-params db)))

(re-frame/reg-sub
 ::page-failure
 (fn [db]
   (when-let [error (-> db :page-failure first)] 
     (if (= 500 (:status error))
       "System error occured. If you are stuck, please notify ben@integreatconsult.com."
       (:message error)))))

(re-frame/reg-sub
 ::yodlee-merchants
 (fn [db]
   (:yodlee-merchants db)))