workspaces

#!/usr/bin/env bb
(require '[babashka.process :as p :refer [shell process destroy-tree]]
         '[clojure.java.io :as io])

(def workspace-stream
  (process
   {:err :inherit
    :shutdown destroy-tree}
   (str "swaymsg -t subscribe -m \"['workspace', 'window']\"")))

(defn- sway-cmd [type]
  (as-> (str "swaymsg -t " type) clients
    (shell {:out :string} clients)
    (:out clients)
    (json/parse-string clients true)))

(defn- get-tree []
  (sway-cmd "get_tree"))

(defn- get-displays []
  (as-> (get-tree) tree
    (:nodes tree)
    (remove (fn [cand] (#{"__i3"} (:name cand))) tree)))

(defn gtk-theme []
  (-> {:out :string}
      (shell "gsettings get org.gnome.desktop.interface icon-theme")
      :out
      str/split-lines
      first
      (str/replace #"'" "")))

(defn flatpak-name [class]
  (->> (shell {:out :string} "flatpak list --app")
       :out
       str/split-lines
       (some
        (fn [line]
          (let [[name id & _] (str/split line #"\t")]
            (when (= name class)
              id))))))

(defn find-icon [name]
  (when name
    (first
     (remove
      nil?
      (flatten
       (for [theme [(gtk-theme) "hicolor"]]
         (for [path ["scalable/apps" "apps/scalable"]]
           (for [file [name (str/lower-case name) (flatpak-name name)]]
             (for [root ["/usr/local/share/icons" "/usr/share/icons" "~/.icons" "~/.local/share/icons" "/var/lib/flatpak/exports/share/icons"]]
               (let [file (fs/expand-home (fs/path root theme path (str file ".svg")))]
                 (when (fs/exists? file)
                   (str file))))))))))))

(def get-icon (memoize find-icon))

(defn- parse-client [client]
  (merge
   (select-keys client [:name :focused :urgent :visible])
   {:icon (or (get-icon (:app_id client))
              (get-icon (get-in client [:window_properties :instance]))
              (get-icon (get-in client [:window_properties :class]))
              "")}))

(defn- representation->clients [workspace]
  (reduce
   (fn [clients client]
     (conj
      clients
      (if (#{"splitv" "splith" "tabbed"} (:layout client))
        (map parse-client (:nodes client))
        (parse-client client))))
   []
   (:nodes workspace)))

(defn- some-in-tree [key tree]
  (true? (or (some key tree)
             (some (fn [container]
                     (some key (:nodes container)))
                   tree))))

(defn workspace-tree []
  (reduce
   (fn [result display]
     (let [nodes (:nodes display)]
       (conj
        result
        (map (fn [workspace]
               {:name (:name workspace)
                :clients (representation->clients workspace)
                :focused (or (and (empty? (:nodes workspace))
                                  (some-in-tree :focused (:nodes display)))
                             (some-in-tree :focused (:nodes workspace)))
                :visible (or (empty? (:nodes workspace))
                             (some-in-tree :visible (:nodes workspace)))})
             nodes))))
   []
   (get-displays)))

(defn output []
  (->> (workspace-tree)
       json/generate-string
       println))

(output)

(with-open [rdr (io/reader (:out workspace-stream))]
  (binding [*in* rdr]
    (loop []
      (when-let [line (-> (read-line) (json/parse-string true))]
        (output)
        (recur)))))