eternalcore-api/src/main/java/com/eternalcode/core/feature/msgtoggle/MsgToggleService.java (1)

6-12: Add documentation to explain the interface's purpose.

Adding some simple comments would help other developers understand what this interface does and how to use it.

 public interface MsgToggleService {
+    /**
+     * Checks if a player has message toggle enabled
+     * @param uuid Player's UUID
+     * @return Future containing true if messages are toggled off
+     */
     CompletableFuture<Boolean> hasMsgToggled(UUID uuid);

+    /**
+     * Updates a player's message toggle state
+     * @param uuid Player's UUID
+     * @param toggle True to enable message blocking, false to disable
+     */
     void toggleMsg(UUID uuid, boolean toggle);
 }

eternalcore-core/src/main/java/com/eternalcode/core/feature/msgtoggle/MsgToggleRepository.java (1)

10-10: Make method name clearer.

The name setToggledOff might be confusing when used with false. Consider renaming it to setToggleState to better reflect its purpose.

-    CompletableFuture<Void> setToggledOff(UUID uuid, boolean toggledOff);
+    CompletableFuture<Void> setToggleState(UUID uuid, boolean enabled);

eternalcore-core/src/main/java/com/eternalcode/core/feature/msgtoggle/MsgToggleServiceImpl.java (1)

26-29: Consider removing @Blocking annotation

The @Blocking annotation might be misleading here since the repository operation could be asynchronous.

eternalcore-core/src/main/java/com/eternalcode/core/feature/msgtoggle/MsgToggleRepositoryOrmLite.java (1)

31-34: Simplify CompletableFuture chain

The thenApply(status -> null) can be replaced with thenRun(() -> {}) for better readability.

-    public CompletableFuture<Void> setToggledOff(UUID uuid, boolean toggledOff) {
-        return this.save(MsgToggleWrapper.class, new MsgToggleWrapper(uuid, toggledOff))
-            .thenApply(status -> null);
-    }
+    public CompletableFuture<Void> setToggledOff(UUID uuid, boolean toggledOff) {
+        return this.save(MsgToggleWrapper.class, new MsgToggleWrapper(uuid, toggledOff))
+            .thenRun(() -> {});
+    }

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/PrivateChatServiceImpl.java (1)

62-78: Improve async operation flow

The nested async operations can be flattened using CompletableFuture's composition methods for better readability.

-        this.msgToggleService.hasMsgToggled(uniqueId).thenAccept(hasMsgToggled -> {
-            if (hasMsgToggled) {
-                this.noticeService.player(sender.getUniqueId(), translation -> translation.privateChat().msgToggledOff());
-
-                return;
-            }
-
-            this.ignoreService.isIgnored(uniqueId, sender.getUniqueId()).thenAccept(isIgnored -> {
-                if (!isIgnored) {
-                    this.replies.put(uniqueId, sender.getUniqueId());
-                    this.replies.put(sender.getUniqueId(), uniqueId);
-                }
-
-                PrivateChatEvent event = new PrivateChatEvent(sender.getUniqueId(), uniqueId, message);
-                this.eventCaller.callEvent(event);
-                this.presenter.onPrivate(new PrivateMessage(sender, target, event.getContent(), this.socialSpy, isIgnored));
-            });
-        });
+        this.msgToggleService.hasMsgToggled(uniqueId)
+            .thenCompose(hasMsgToggled -> {
+                if (hasMsgToggled) {
+                    this.noticeService.player(sender.getUniqueId(), translation -> translation.privateChat().msgToggledOff());
+                    return CompletableFuture.completedFuture(null);
+                }
+                return this.ignoreService.isIgnored(uniqueId, sender.getUniqueId())
+                    .thenAccept(isIgnored -> {
+                        if (!isIgnored) {
+                            this.replies.put(uniqueId, sender.getUniqueId());
+                            this.replies.put(sender.getUniqueId(), uniqueId);
+                        }
+                        PrivateChatEvent event = new PrivateChatEvent(sender.getUniqueId(), uniqueId, message);
+                        this.eventCaller.callEvent(event);
+                        this.presenter.onPrivate(new PrivateMessage(sender, target, event.getContent(), this.socialSpy, isIgnored));
+                    });
+            });

eternalcore-core/src/main/java/com/eternalcode/core/translation/implementation/ENTranslation.java (1)

499-507: Consider standardizing color usage across messages.

While the messages are clear, the color usage could be more consistent:

• Some messages use <red>disabled while others use <green>enabled
• The player name highlighting varies between messages

Consider standardizing to:

-        public Notice msgToggledOff = Notice.chat("<red>► <dark_red>This player has disabled private messages!");
+        public Notice msgToggledOff = Notice.chat("<red>► <white>This player has <red>disabled</red> private messages!");

-        public Notice msgToggledSelf = Notice.chat("<green>► <white>Private messages have been <red>disabled<white>!");
+        public Notice msgToggledSelf = Notice.chat("<green>► <white>Private messages have been <red>disabled</red>!");

-        public Notice msgUntoggleSelf = Notice.chat("<green>► <white>Private messages have been <green>enabled<white>!");
+        public Notice msgUntoggleSelf = Notice.chat("<green>► <white>Private messages have been <green>enabled</green>!");

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleRepository.java (1)

11-11: Consider renaming the parameter for clarity

The parameter name toggledOff might be confusing since it can be either ON or OFF. Consider using just state or toggleState instead.

-    CompletableFuture<Void> setPrivateChatToggle(UUID uuid, PrivateChatToggleState toggledOff);
+    CompletableFuture<Void> setPrivateChatToggle(UUID uuid, PrivateChatToggleState state);

eternalcore-api/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggle.java (2)

10-12: Consider removing unused constructor

The empty constructor doesn't initialize the fields. If all fields are required, consider removing it.

---

14-17: Make parameter name match field name

For consistency, rename the parameter to match the field name.

-    public PrivateChatToggle(UUID uuid, PrivateChatToggleState toggle) {
+    public PrivateChatToggle(UUID uuid, PrivateChatToggleState state) {
         this.uuid = uuid;
-        this.state = toggle;
+        this.state = state;
     }

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleServiceImpl.java (1)

18-18: Remove extra blank lines

There are unnecessary blank lines that can be removed.

Also applies to: 29-29

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/PrivateChatServiceImpl.java (1)

63-79: Consider combining async operations.

The nested async operations could be flattened using thenCompose for better readability and error handling.

-        this.privateChatToggleService.getPrivateChatToggleState(uniqueId).thenAccept(privateChatToggleState -> {
-            if (privateChatToggleState.equals(PrivateChatToggleState.ON)) {
-                this.noticeService.player(sender.getUniqueId(), translation -> translation.privateChat().receiverDisabledMessages());
-
-                return;
-            }
-
-            this.ignoreService.isIgnored(uniqueId, sender.getUniqueId()).thenAccept(isIgnored -> {
+        this.privateChatToggleService.getPrivateChatToggleState(uniqueId)
+            .thenCompose(privateChatToggleState -> {
+                if (privateChatToggleState.equals(PrivateChatToggleState.ON)) {
+                    this.noticeService.player(sender.getUniqueId(), 
+                        translation -> translation.privateChat().receiverDisabledMessages());
+                    return CompletableFuture.completedFuture(null);
+                }
+                return this.ignoreService.isIgnored(uniqueId, sender.getUniqueId())
+                    .thenAccept(isIgnored -> {
                 if (!isIgnored) {
                     this.replies.put(uniqueId, sender.getUniqueId());
                     this.replies.put(sender.getUniqueId(), uniqueId);
                 }

                 PrivateChatEvent event = new PrivateChatEvent(sender.getUniqueId(), uniqueId, message);
                 this.eventCaller.callEvent(event);
                 this.presenter.onPrivate(new PrivateMessage(sender, target, event.getContent(), this.socialSpy, isIgnored));
-            });
-        });
+            });
+        })
+        .exceptionally(throwable -> {
+            this.noticeService.player(sender.getUniqueId(), 
+                translation -> translation.general().error());
+            return null;
+        });

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleRepositoryOrmLite.java (2)

31-34: Simplify the CompletableFuture chain.

The thenApply(status -> null) can be replaced with a simpler method.

-        return this.save(PrivateChatToggleWrapper.class, new PrivateChatToggleWrapper(uuid, toggledOff))
-            .thenApply(status -> null);
+        return this.save(PrivateChatToggleWrapper.class, new PrivateChatToggleWrapper(uuid, toggledOff))
+            .thenRun(() -> {});

---

30-34: Add documentation for the return value.

The method returns null via thenApply(status -> null). This should be documented or reconsidered.

+    /**
+     * Sets the private chat toggle state for a player.
+     * @return A CompletableFuture that completes when the save operation is done.
+     */
     @Override
     public CompletableFuture<Void> setPrivateChatToggle(UUID uuid, PrivateChatToggleState toggledOff) {
         return this.save(PrivateChatToggleWrapper.class, new PrivateChatToggleWrapper(uuid, toggledOff))
             .thenApply(status -> null);
     }

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleCommand.java (2)

116-123: Consider merging toggle methods to reduce duplication.

The toggleOn and toggleOff methods are very similar and could be combined.

-    private void toggleOn(UUID uniqueId) {
-        this.privateChatToggleService.togglePrivateChat(uniqueId, PrivateChatToggleState.ON);
-
-        this.noticeService.create()
-            .notice(translation -> translation.privateChat().selfMessagesDisabled())
-            .player(uniqueId)
-            .send();
-    }
-
-    private void toggleOff(UUID uniqueId) {
-        this.privateChatToggleService.togglePrivateChat(uniqueId, PrivateChatToggleState.OFF);
-
-        this.noticeService.create()
-            .notice(translation -> translation.privateChat().selfMessagesEnabled())
-            .player(uniqueId)
-            .send();
-    }
+    private void toggle(UUID uniqueId, PrivateChatToggleState state) {
+        this.privateChatToggleService.togglePrivateChat(uniqueId, state);
+
+        this.noticeService.create()
+            .notice(translation -> state == PrivateChatToggleState.ON 
+                ? translation.privateChat().selfMessagesDisabled()
+                : translation.privateChat().selfMessagesEnabled())
+            .player(uniqueId)
+            .send();
+    }

Also applies to: 125-132

---

116-132: Reduce code duplication in notification methods.

The toggleOn and toggleOff methods have similar notification logic.

Consider extracting the notification logic to a separate method:

+    private void sendToggleNotification(UUID uniqueId, boolean enabled) {
+        this.noticeService.create()
+            .notice(translation -> enabled 
+                ? translation.privateChat().selfMessagesEnabled()
+                : translation.privateChat().selfMessagesDisabled())
+            .player(uniqueId)
+            .send();
+    }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleCommand.java (1)

36-49: ⚠️ Potential issue

Add error handling for the async operation.

The async operation could fail silently. Let's add proper error handling.

     if (state == null) {
         CompletableFuture<PrivateChatToggleState> privateChatToggleState = this.privateChatToggleService.getPrivateChatToggleState(context.getUniqueId());

         privateChatToggleState.thenAccept(toggleState -> {
             if (toggleState.equals(PrivateChatToggleState.OFF)) {
                 this.toggleOn(uniqueId);
             }
             else {
                 this.toggleOff(uniqueId);
             }
-        });
+        }).exceptionally(throwable -> {
+            this.noticeService.create()
+                .notice(translation -> translation.general().error())
+                .player(uniqueId)
+                .send();
+            return null;
+        });

eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleServiceImpl.java (3)

23-29: Update cache on repository fetch

When fetching from the repository, the result should be cached to avoid repeated database calls.

     @Override
     public CompletableFuture<PrivateChatToggleState> getPrivateChatToggleState(UUID uuid) {
         if (this.cachedToggleStates.containsKey(uuid)) {
             return CompletableFuture.completedFuture(this.cachedToggleStates.get(uuid));
         }
 
-        return this.msgToggleRepository.getPrivateChatToggleState(uuid);
+        return this.msgToggleRepository.getPrivateChatToggleState(uuid)
+            .thenApply(state -> {
+                this.cachedToggleStates.put(uuid, state);
+                return state;
+            });
     }

---

32-35: Handle repository update failures

If the repository update fails, the cache and database could get out of sync. Consider handling the error case.

     @Override
     public void togglePrivateChat(UUID uuid, PrivateChatToggleState toggle) {
-        this.cachedToggleStates.put(uuid, toggle);
-        this.msgToggleRepository.setPrivateChatToggle(uuid, toggle);
+        this.msgToggleRepository.setPrivateChatToggle(uuid, toggle)
+            .thenAccept(ignored -> this.cachedToggleStates.put(uuid, toggle))
+            .exceptionally(throwable -> {
+                // Log error and remove from cache to force re-fetch
+                this.cachedToggleStates.remove(uuid);
+                return null;
+            });
     }

---

13-13: Add basic cache management

Consider adding simple cache management features like:

• Maximum cache size limit
• Cache entry expiration
• Cache clear on player logout

This will help prevent memory issues while keeping the performance benefits.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: CitralFlo
PR: EternalCodeTeam/EternalCore#896
File: eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleServiceImpl.java:24-27
Timestamp: 2025-01-28T21:35:47.750Z
Learning: In EternalCore, async operations using CompletableFuture should remain non-blocking. Avoid using .join() or similar blocking operations to maintain better performance and scalability.

Learnt from: CitralFlo
PR: EternalCodeTeam/EternalCore#896
File: eternalcore-api/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggle.java:10-11
Timestamp: 2025-01-28T21:35:04.888Z
Learning: Fields in classes used with ORM Lite repository must have package-private (default) access modifier, not private, to allow ORM Lite to access them properly.

Learnt from: CitralFlo
PR: EternalCodeTeam/EternalCore#896
File: eternalcore-core/src/main/java/com/eternalcode/core/feature/privatechat/toggle/PrivateChatToggleCommand.java:92-102
Timestamp: 2025-01-28T21:37:36.945Z
Learning: In the EternalCore plugin's private chat feature, PrivateChatToggleState.ON means message blocking is enabled (no messages will be received), while PrivateChatToggleState.OFF means messages are allowed.