(ns shoreleave.browser.blob)

(defn- window-url-prop
  []
  (or (.-URL js/window) (.-webkitURL js/window)))

(defn raw-blob
  ([file-parts]
   (js/Blob. file-parts))
  ([file-parts prop-bag]
   (js/Blob. file-parts prop-bag)))

(defn blob
  ([file-parts]
   (js/Blob. (clj->js file-parts)))
  ([file-parts content-type-str]
   (js/Blob. (clj->js file-parts) (js-obj "type" content-type-str))))

(defn object-url!
  [file-or-blob]
  (let [url (window-url-prop)]
    (when url
      (.createObjectURL url file-or-blob))))

(defn revoke-object-url!
  [obj-url]
  (let [url (window-url-prop)]
    (when url
      (.revokeObjectURL url obj-url))))

(ns shoreleave.browser.cookies
  (:require [goog.net.Cookies :as gCookies]
            [goog.string :as gstr]))

(declare as-hash-map)

(extend-type goog.net.Cookies

  ILookup
  (-lookup
    ([c k]
      (-lookup c k nil))
    ([c k not-found] ;gstr/urlDecode
      (let [v (.get c (name k) not-found)]
        (if (string? v)
          (gstr/urlDecode v)
          v))
      #_(.get c (name k) not-found)))

  ISeqable
  (-seq [c]
    (map vector (.getKeys c) (.getValues c)))

  ICounted
  (-count  [c] (.getCount c))

  IFn
  (-invoke
    ([c k]
      (-lookup c k))
    ([c k not-found]
      (-lookup c k not-found))) 

  ITransientCollection
  (-persistent! [c] (as-hash-map c))
  ;(-conj! [c v] nil)

  ITransientAssociative
  (-assoc! [c k v & opts]
    (when-let [k (and (.isValidName c (name k)) (name k))]
      (let [{:keys [max-age path domain secure?]} (apply hash-map opts)]
        (.set c k v max-age path domain secure?))))

  ITransientMap
  (-dissoc! [c k & opts]
    (when-let [k (and (.isValidName c (name k)) (name k))]
      (let [{:keys [path domain]} (apply hash-map opts)]
        (.remove c k path domain))))

  IAssociative
  (-assoc [c k v]
    (-assoc (-persistent! c) k v))
  (-contains-key? [c k]
    (.containsKey c (name k)))

  ;IPrintable
  ;(-pr-seq  [c opts]
  ;  #_(let  [pr-pair  (fn  [keyval]  (pr-sequential pr-seq "" " " "" opts keyval))]
  ;    (pr-sequential pr-pair "{" ", " "}" opts c))
  ;  (-pr-seq (-persistent! c) opts))
  IPrintWithWriter
  (-pr-writer [c writer opts]
    (-write writer (-persistent! c)))

  ;; TODO: using the persistent version here might be a bad idea
  IHash
  (-hash [c]
    (-hash (-persistent! c))))

(def cookies (goog.net.Cookies. js/document))

(defn as-hash-map
  ([]
   (as-hash-map cookies))
  ([cks]
   (zipmap (.getKeys cks) (.getValues cks))))

(defn cookies-enabled?
  ([]
   (cookies-enabled? cookies))
  ([cks]
   (.isEnabled cks)))

(defn empty! [cks]
  (.clear cks))

(ns shoreleave.browser.history
  (:require [goog.events :as gevents]
            [goog.History :as ghistory]
            [goog.history.EventType :as history-event]
            [goog.history.Html5History :as history5]))

(declare history)

(defn navigate-callback
  ([callback-fn]
   (navigate-callback history callback-fn))
  ([hist callback-fn]
   (gevents/listen hist history-event/NAVIGATE
                  (fn [e]
                    (callback-fn {:token (keyword (.-token e))
                                  :type (.-type e)
                                  :navigation? (.-isNavigation e)})))))

(defn init-history
  []
  (let [history (if (history5/isSupported)
                  (goog.history.Html5History.)
                  (goog.History.))]
                   (.setEnabled history true)
                   (gevents/unlisten (.-window_ history) (.-POPSTATE gevents/EventType) ; This is a patch-hack to ignore double events
                                     (.-onHistoryEvent_ history), false, history)
                   history))

(def history (init-history))
(defn get-token
  [hist]
  (.getToken hist))

(defn set-token!
  [hist tok]
  (.setToken hist tok))

(defn replace-token! [hist tok] (.replaceToken hist tok))

(defn push-state [hist state-map]
  (let [{:keys [state title url]
         :or {state nil
              title js/document.title}} state-map]
    (apply js/window.history.pushState (map clj->js [state title url]))
    (.dispatchEvent hist (goog.history.Event. url false))))

(ns shoreleave.browser.storage.localstorage
  (:require [cljs.reader :as reader]
            [goog.storage.mechanism.HTML5LocalStorage :as html5ls]
            [shoreleave.browser.storage.webstorage]))

(def ls-watchers (atom {}))

(extend-type goog.storage.mechanism.HTML5LocalStorage

  IWatchable
  (-notify-watches [ls oldval newval]
    (doseq  [[key f] @ls-watchers]
      (f key ls oldval newval)))
  (-add-watch [ls key f]
    (swap! ls-watchers assoc key f))
  (-remove-watch [ls key]
    (swap! ls-watchers dissoc key)))

(defn storage
  []
  (goog.storage.mechanism.HTML5LocalStorage.))

(def localstorage (storage))

(ns shoreleave.browser.storage.sessionstorage
  (:require [cljs.reader :as reader]
            [goog.storage.mechanism.HTML5SessionStorage :as html5ss]
            [shoreleave.browser.storage.webstorage]))

(def ss-watchers (atom {}))

(extend-type goog.storage.mechanism.HTML5SessionStorage

  IWatchable
  (-notify-watches [ss oldval newval]
    (doseq  [[key f] @ss-watchers]
      (f key ss oldval newval)))
  (-add-watch [ss key f]
    (swap! ss-watchers assoc key f))
  (-remove-watch [ss key]
    (swap! ss-watchers dissoc key)))

(defn storage
  []
  (goog.storage.mechanism.HTML5SessionStorage.))

(def sessionstorage (storage))

(ns shoreleave.browser.storage.webstorage
  (:require [cljs.reader :as reader]
            [goog.storage.mechanism.HTML5WebStorage :as html5webstorage]
            [goog.iter :as g-iter]))

(defn storage-keys [ls]
  (g-iter/toArray (.__iterator__ ls true)))
(defn storage-values [ls]
  (g-iter/toArray (.__iterator__ ls false)))
(defn as-hash-map
  ([storage]
   (zipmap (storage-keys storage) (storage-values storage))))

(extend-type goog.storage.mechanism.HTML5WebStorage
  
  ILookup
  (-lookup
    ([ls k]
      (-lookup ls k nil))
    ([ls k not-found]
      (let [read-value (if-let [v (not-empty (.get ls (name k)))]
                        v
                        (pr-str not-found))]
        (reader/read-string read-value))))

  ISeqable
  (-seq [ls]
    (map vector (storage-keys ls) (storage-values ls)))

  ICounted
  (-count  [ls] (.getCount ls))

  IFn
  (-invoke
    ([ls k]
      (-lookup ls k))
    ([ls k not-found]
      (-lookup ls k not-found))) 

  ITransientCollection
  (-persistent! [ls] (as-hash-map ls))
  ;(-conj! [c v] nil)

  ITransientAssociative
  (-assoc! [ls k v]
    (let [old-val (-lookup ls k)]
      (.set ls (name k) (pr-str v))
      (-notify-watches ls {k old-val} {k v})
      ls))

  ITransientMap
  (-dissoc! [ls k]
    (do
      (.remove ls (name k))
      ls))

  ;IPrintable
  ;(-pr-seq  [ls opts]
   ; #_(let  [pr-pair  (fn  [keyval]  (pr-sequential pr-seq "" " " "" opts keyval))]
   ;   (pr-sequential pr-pair "{" ", " "}" opts ls))
   ; (-pr-seq (-persistent! ls) opts))
  IPrintWithWriter
  (-pr-writer [ls writer opts]
    (let [pers-st (-persistent! ls)]
     (-write writer (-persistent! ls)))))

(defn empty!
  [ls]
  (.clear ls))