From 5a99ba27866d457477c376ca0514223fc86403b6 Mon Sep 17 00:00:00 2001
From: Pixirora <rina@pixirora.dev>
Date: Fri, 4 Oct 2024 21:21:33 -0400
Subject: [PATCH] prevent concurrency issues

---
 .../kitten_heart/impl/EventHandling.java      | 66 ++++++++++++-------
 .../impl/config/ConfigManager.java            | 12 ++--
 2 files changed, 50 insertions(+), 28 deletions(-)

diff --git a/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/EventHandling.java b/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/EventHandling.java
index 9d7009d..bcc0ed3 100644
--- a/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/EventHandling.java
+++ b/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/EventHandling.java
@@ -58,41 +58,55 @@ private static void handleTrackEnd(ListeningProgress progress, Pair<ResourcePath
     public static void init() {
     }
 
-    public static synchronized void tick() {
-        for (Runnable task : MAIN_THREAD_TASKS) {
-            task.run();
+    public static void tick() {
+        synchronized (MAIN_THREAD_TASKS) {
+            for (Runnable task : MAIN_THREAD_TASKS) {
+                task.run();
+            }
+
+            MAIN_THREAD_TASKS.clear();
         }
+    }
 
-        MAIN_THREAD_TASKS.clear();
+    public static void addMainThreadTask(Runnable task) {
+        synchronized (MAIN_THREAD_TASKS) {
+            MAIN_THREAD_TASKS.add(task);
+        }
     }
 
     public static boolean isTracking(ListeningProgress progress) {
-        return PLAYING_TRACKS.containsKey(progress);
+        synchronized (PLAYING_TRACKS) {
+            return PLAYING_TRACKS.containsKey(progress);
+        }
     }
 
     public static boolean isTrackingAnything() {
-        return PLAYING_TRACKS.size() > 0;
+        synchronized (PLAYING_TRACKS) {
+            return PLAYING_TRACKS.size() > 0;
+        }
     }
 
-    public static synchronized void stop() {
-        for (Map.Entry<ListeningProgress, Pair<ResourcePath, Optional<Track>>> entry : PLAYING_TRACKS.entrySet()) {
-            handleTrackEnd(entry.getKey(), entry.getValue());
+    public static void stop() {
+        synchronized (PLAYING_TRACKS) {
+            PLAYING_TRACKS.forEach(EventHandling::handleTrackEnd);
         }
 
         tick(); // Tick one last time to clear any remaining tasks out.
     }
 
-    public static synchronized Collection<PlayingSong> playingSongs() {
-        List<PlayingSong> songs = new ArrayList<>();
+    public static Collection<PlayingSong> playingSongs() {
+        synchronized (PLAYING_TRACKS) {
+            List<PlayingSong> songs = new ArrayList<>();
 
-        for (Map.Entry<ListeningProgress, Pair<ResourcePath, Optional<Track>>> entry : PLAYING_TRACKS.entrySet()) {
-            songs.add(new PlayingSong(entry.getValue().second(), entry.getKey()));
-        }
+            for (Map.Entry<ListeningProgress, Pair<ResourcePath, Optional<Track>>> entry : PLAYING_TRACKS.entrySet()) {
+                songs.add(new PlayingSong(entry.getValue().second(), entry.getKey()));
+            }
 
-        return songs;
+            return songs;
+        }
     }
 
-    private static synchronized TrackStartEvent createStartEvent(ResourcePath path, ListeningProgress progress) {
+    private static TrackStartEvent createStartEvent(ResourcePath path, ListeningProgress progress) {
         Optional<Track> track = MusicMetadata.matchTrack(path);
 
         if (track.isPresent()) {
@@ -101,7 +115,9 @@ private static synchronized TrackStartEvent createStartEvent(ResourcePath path,
             MusicMetadata.asMutable().giveDuration(track.get(), songDuration);
         }
 
-        PLAYING_TRACKS.put(progress, Pair.of(path, track));
+        synchronized (PLAYING_TRACKS) {
+            PLAYING_TRACKS.put(progress, Pair.of(path, track));
+        }
 
         return new TrackEventImpl(path, track, progress);
     }
@@ -112,15 +128,17 @@ private static Duration songDuration(ResourcePath path) throws IOException {
         }
     }
 
-    private static synchronized Pair<ResourcePath, Optional<Track>> getTrackInfo(ListeningProgress progress,
+    private static Pair<ResourcePath, Optional<Track>> getTrackInfo(ListeningProgress progress,
             boolean flushFromMap) {
-        Pair<ResourcePath, Optional<Track>> trackInfo = Objects.requireNonNull(PLAYING_TRACKS.get(progress));
+        synchronized (PLAYING_TRACKS) {
+            Pair<ResourcePath, Optional<Track>> trackInfo = Objects.requireNonNull(PLAYING_TRACKS.get(progress));
 
-        if (flushFromMap) {
-            PLAYING_TRACKS.remove(progress);
-        }
+            if (flushFromMap) {
+                PLAYING_TRACKS.remove(progress);
+            }
 
-        return trackInfo;
+            return trackInfo;
+        }
     }
 
     private static void processEvent(Consumer<MusicEventListener> event) {
@@ -128,7 +146,7 @@ private static void processEvent(Consumer<MusicEventListener> event) {
             Runnable eventAction = () -> event.accept(listener);
 
             if (listener.isSynchronized()) {
-                MAIN_THREAD_TASKS.add(eventAction);
+                addMainThreadTask(eventAction);
             } else {
                 KitTunes.EXECUTOR.execute(eventAction);
             }
diff --git a/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/config/ConfigManager.java b/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/config/ConfigManager.java
index 3be322e..f691d7e 100644
--- a/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/config/ConfigManager.java
+++ b/projects/kitten-heart/src/main/java/net/pixaurora/kitten_heart/impl/config/ConfigManager.java
@@ -34,12 +34,16 @@ public ConfigManager(Path savePath, Class<T> configClass, Supplier<T> defaults)
         this.config = this.createConfig();
     }
 
-    public synchronized void execute(Consumer<T> task) {
-        task.accept(this.config);
+    public void execute(Consumer<T> task) {
+        synchronized (this) {
+            task.accept(this.config);
+        }
     }
 
-    public synchronized void save() throws IOException {
-        this.saveAtomically(config);
+    public void save() throws IOException {
+        synchronized (this) {
+            this.saveAtomically(config);
+        }
     }
 
     private void saveAtomically(T config) throws IOException {