;; This buffer is for Clojure experiments and evaluation.

;; Press C-j to evaluate the last expression.

;; You can also press C-u C-j to evaluate the expression and pretty-print its result.


(user/start-db)

(def c 
  (first (get-square-clients "NGOP")))

(def l  (first (filter :square-location/client-location (:client/square-locations c))))

(def base @(settlements c l))
(def base-result @(daily-settlements c l))

base-result


(def new 
  @(de/chain (manifold-api-call 
               {:url     (str "https://connect.squareup.com/v2/payouts/?"
                              (url/map->query 
                                {:location_id (:square-location/square-id l)
                                 :begin_time "2023-07-22T00:00:00Z"}) )
                :method  :get
                :headers (client-base-headers c "2023-04-19")
                })
             :body
             :payouts
             (fn [payouts]
               (->> payouts
                    (s/->source)
                    (s/map (fn [payout]
                             (mu/with-context {}
                               (log/info ::looking-up-payout
                                         :payout-id (:id payout))
                               (de/chain 
                                 (manifold-api-call 
                                   {:url     (str "https://connect.squareup.com/v2/payouts/" (:id payout) "/payout-entries")
                                    :method  :get
                                    :headers (client-base-headers c "2023-04-19")
                                    :as      :json})
                                 :body
                                 :payout_entries
                                 (fn [b]
                                   (assoc payout :payout_entries b))))))
                    (s/buffer 10)
                    (s/realize-each)
                    (s/reduce conj [])))
             (fn [settlements]
               (log/info ::transforming-settlements)
               (try 
                 (->> (for [settlement settlements
                            :let       [best-sales-date (some->> (dc/q '[:find ?s4 (count ?s)
                                                                         :in $ ?settlement-id
                                                                         :where
                                                                         [?settlement :expected-deposit/external-id ?settlement-id]
                                                                         [?settlement :expected-deposit/charges ?c]
                                                                         [?s :sales-order/charges ?c]
                                                                         [?s :sales-order/date ?sales-date]
                                                                         [(clj-time.coerce/to-date-time ?sales-date) ?s2]
                                                                         [(auto-ap.time/localize ?s2) ?s3]
                                                                         [(clj-time.coerce/to-local-date ?s3) ?s4]]
                                                                       (dc/db conn)
                                                                       (str "square/payout/" (:id settlement)))
                                                                 (sort-by last)
                                                                 last
                                                                 first
                                                                 coerce/to-date-time
                                                                 atime/as-local-time
                                                                 coerce/to-date)
                                        
                                        ;; TODO delete this -  this is only needed during the short transformation time
                                        equivalent-already-exists? (seq (dc/q '[:find ?s
                                                                                :in $ ?c ?a
                                                                                :where
                                                                                [?s :expected-deposit/date ?ed]
                                                                                [(>= ?ed #inst "2023-07-10")]
                                                                                [(<= ?ed #inst "2023-07-26")]
                                                                                [?s :expected-deposit/client ?c]
                                                                                [?s :expected-deposit/external-id ?eid]
                                                                                [(clojure.string/includes? ?eid "settlement")]
                                                                                [?s :expected-deposit/total ?t]
                                                                                [(iol-ion.query/dollars= ?t ?a)]
                                                                                ]
                                                                              (dc/db conn)
                                                                              (:db/id c)
                                                                              (amount->money (:amount_money settlement))
                                                                              ))]
                            :when (not equivalent-already-exists?)]
                        #:expected-deposit {:external-id (str "square/payout/" (:id settlement))
                                            :vendor      :vendor/ccp-square
                                            :status      :expected-deposit-status/pending
                                            :total       (amount->money (:amount_money settlement))
                                            :client      (:db/id c)
                                            :location    (:square-location/client-location l)
                                            :fee         (- (reduce + 0.0 (map (fn [entry]
                                                                                 (if (= (:type entry) "REFUND")
                                                                                   (- (amount->money (:fee_amount_money entry)))
                                                                                   (amount->money (:fee_amount_money entry))))
                                                                               (:payout_entries settlement))))
                                            :date        (-> (:created_at settlement)
                                                             (coerce/to-date))
                                            :sales-date  (or best-sales-date
                                                             (-> (:initiated_at settlement)
                                                                 (coerce/to-date)))
                                            :charges     (reverse (->> (:payout_entries settlement)
                                                                       (filter (comp :payment_id :type_charge_details))
                                                                       (map (fn [p] {:charge/external-id (str "square/charge/" (:payment_id (:type_charge_details p)))}))))})
                      (filter :expected-deposit/date)
                      (into []))
                 (catch Throwable e
                   (log/error ::transform-settlement-failed
                              :exception e))))
             ))

(clojure.data/diff 
  (update (first (drop 2 new)) :expected-deposit/charges #(into #{} %))

  (update (first (reverse base-result)) :expected-deposit/charges #(into #{} %)))



@(get-payment c  "lo1H33efDPosiQBNSni0fFcGEXGZY")