From f94d77cfaca77586ba9de3fad05be7e3a9e092c0 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 14 Dec 2023 14:52:17 +0100
Subject: [PATCH 01/50] feat(gui): Begin first implementation of guis

---
 .../rushyverse/api/extension/_String.kt       |  15 +++
 .../com/github/rushyverse/api/gui/GUI.kt      | 102 ++++++++++++++++++
 .../github/rushyverse/api/gui/PersonalGUI.kt  |  81 ++++++++++++++
 .../github/rushyverse/api/gui/SharedGUI.kt    |  80 ++++++++++++++
 .../rushyverse/api/listener/GUIListener.kt    |  45 ++++++++
 .../github/rushyverse/api/player/Client.kt    |  11 +-
 .../rushyverse/api/player/ClientManager.kt    |  79 ++++++++++++--
 .../api/player/ClientManagerImpl.kt           |  64 -----------
 .../rushyverse/api/player/gui/GUIManager.kt   |  58 ++++++++++
 9 files changed, 461 insertions(+), 74 deletions(-)
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt
 delete mode 100644 src/main/kotlin/com/github/rushyverse/api/player/ClientManagerImpl.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt

diff --git a/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt b/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt
index 59523834..63ab7bfa 100644
--- a/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt
@@ -3,6 +3,8 @@
 
 package com.github.rushyverse.api.extension
 
+import com.github.rushyverse.api.translation.Translator
+import com.github.rushyverse.api.translation.getComponent
 import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.TextComponent
 import net.kyori.adventure.text.format.NamedTextColor
@@ -263,3 +265,16 @@ public fun StringBuilder.deleteLast(size: Int): StringBuilder {
         else -> delete(length - size, length)
     }
 }
+
+/**
+ * If the string contains a dot, it will be considered as a translation path, and will be translated.
+ * However, if the string doesn't contain a dot, it will be considered as a component.
+ * @receiver String to translate or to convert to a component.
+ * @param translator Translator.
+ * @param locale Locale to use for translation.
+ * @return The translated component or the component created from the string.
+ */
+public fun String.toTranslatedComponent(translator: Translator, locale: Locale): Component {
+    return if (this.contains('.')) translator.getComponent(this, locale)
+    else this.asComponent()
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
new file mode 100644
index 00000000..c60c3f4b
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -0,0 +1,102 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.koin.inject
+import com.github.rushyverse.api.player.Client
+import com.github.rushyverse.api.player.gui.GUIManager
+import java.io.Closeable
+import org.bukkit.Server
+import org.bukkit.entity.HumanEntity
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+
+/**
+ * GUI that can be shared by multiple players.
+ * Only one inventory is created for all the viewers.
+ * @property server Server.
+ * @property manager Manager to register or unregister the GUI.
+ * @property viewers List of viewers.
+ */
+public abstract class GUI: Closeable {
+
+    protected val server: Server by inject()
+
+    private val manager: GUIManager by inject()
+
+    public var isClosed: Boolean = false
+
+    /**
+     * Create the inventory of the GUI.
+     * @return The inventory of the GUI.
+     */
+    protected abstract suspend fun createInventory(client: Client): Inventory
+
+    /**
+     * Open the inventory for the player.
+     * @param client Client to open the inventory for.
+     */
+    public abstract suspend fun open(client: Client)
+
+    /**
+     * Action to do when the client clicks on an item in the inventory.
+     * @param client Client who clicked.
+     * @param clickedItem Item clicked by the client.
+     * @param event Event of the click.
+     */
+    public abstract suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent)
+
+    /**
+     * Close the inventory for the player.
+     * @param client Client to close the inventory for.
+     * @return True if the inventory was closed, false otherwise.
+     */
+    public abstract suspend fun close(client: Client): Boolean
+
+    /**
+     * Close the inventory.
+     * The inventory will be closed for all the viewers.
+     * The GUI will be removed from the listener and the [onClick] function will not be called anymore.
+     */
+    public override fun close() {
+        isClosed = true
+        unregister()
+    }
+
+    /**
+     * Verify that the GUI is open.
+     * If the GUI is closed, throw an exception.
+     */
+    protected fun requireOpen() {
+        require(!isClosed) { "Cannot use a closed GUI" }
+    }
+
+    /**
+     * Get the viewers of the GUI.
+     * @return List of viewers.
+     */
+    public abstract suspend fun viewers(): List<HumanEntity>
+
+    /**
+     * Check if the GUI contains the player.
+     * @param client Client to check.
+     * @return True if the GUI contains the player, false otherwise.
+     */
+    public abstract suspend fun contains(client: Client): Boolean
+
+    /**
+     * Register the GUI to the listener.
+     * @return True if the GUI was registered, false otherwise.
+     */
+    protected fun register(): Boolean {
+        return manager.add(this)
+    }
+
+    /**
+     * Unregister the GUI from the listener.
+     * @return True if the GUI was unregistered, false otherwise.
+     */
+    protected fun unregister(): Boolean {
+        return manager.remove(this)
+    }
+
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
new file mode 100644
index 00000000..a2a7ca06
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -0,0 +1,81 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.extension.toTranslatedComponent
+import com.github.rushyverse.api.koin.inject
+import com.github.rushyverse.api.player.Client
+import com.github.rushyverse.api.translation.Translator
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.bukkit.entity.HumanEntity
+import org.bukkit.event.inventory.InventoryType
+import org.bukkit.inventory.Inventory
+
+/**
+ * GUI where a new inventory is created for each viewer.
+ * @property inventoryType InventoryType
+ * @property title String
+ * @property translator Translator
+ */
+public abstract class PersonalGUI(
+    public val inventoryType: InventoryType,
+    public val title: String
+) : GUI() {
+
+    private val translator: Translator by inject()
+
+    private var inventories: MutableMap<Client, Inventory> = mutableMapOf()
+
+    private val mutex = Mutex()
+
+    override suspend fun open(client: Client) {
+        requireOpen()
+
+        val inventory = createInventory(client)
+
+        mutex.withLock {
+            val oldInventory = inventories[client]
+            inventories[client] = inventory
+            oldInventory
+        }?.close()
+
+        client.requirePlayer().openInventory(inventory)
+    }
+
+    override suspend fun createInventory(client: Client): Inventory {
+        val player = client.requirePlayer()
+        val translatedTitle = title.toTranslatedComponent(translator, client.lang().locale)
+        return server.createInventory(player, inventoryType, translatedTitle).also {
+            fill(client, it)
+        }
+    }
+
+    /**
+     * Fill the inventory with items for the client.
+     * This function is called when the inventory is created.
+     * @param client The client to fill the inventory for.
+     * @param inventory The inventory to fill.
+     */
+    protected abstract suspend fun fill(client: Client, inventory: Inventory)
+
+    override suspend fun close(client: Client): Boolean {
+        return mutex.withLock { inventories.remove(client) }?.close() == 1
+    }
+
+    override suspend fun viewers(): List<HumanEntity> {
+        return mutex.withLock {
+            inventories.values.flatMap(Inventory::getViewers)
+        }
+    }
+
+    override suspend fun contains(client: Client): Boolean {
+        return mutex.withLock {
+            inventories.containsKey(client)
+        }
+    }
+
+    override fun close() {
+        super.close()
+        inventories.values.forEach(Inventory::close)
+        inventories.clear()
+    }
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
new file mode 100644
index 00000000..b984da53
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -0,0 +1,80 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.player.Client
+import net.kyori.adventure.text.Component
+import org.bukkit.entity.HumanEntity
+import org.bukkit.event.inventory.InventoryType
+import org.bukkit.inventory.Inventory
+
+/**
+ * GUI that can be shared by multiple players.
+ * Only one inventory is created for all the viewers.
+ * @property inventoryType Type of the inventory.
+ * @property title Title of the inventory.
+ * @property server Server
+ * @property listener Listener to listen to the clicks on the inventory.
+ * @property viewers List of viewers.
+ * @property inventory Inventory shared by all the viewers.
+ */
+public abstract class SharedGUI(
+    public val inventoryType: InventoryType,
+    public val title: Component
+): GUI() {
+
+    private var inventory: Inventory? = null
+
+    override suspend fun createInventory(client: Client): Inventory {
+        return server.createInventory(null, inventoryType, title).also {
+            fill(it)
+        }
+    }
+
+    public override suspend fun open(client: Client) {
+        val inventory = getOrCreateInventory(client)
+        client.requirePlayer().openInventory(inventory)
+    }
+
+    /**
+     * Get the inventory of the GUI.
+     * If the inventory is not created, create it.
+     * @return The inventory of the GUI.
+     */
+    private suspend fun getOrCreateInventory(client: Client): Inventory {
+        require(!isClosed) { "The GUI is closed" }
+
+        return inventory ?: createInventory(client).also {
+            inventory = it
+            register()
+        }
+    }
+
+    override suspend fun close(client: Client): Boolean {
+        val player = client.requirePlayer()
+        if(player.openInventory.topInventory == inventory) {
+            player.closeInventory()
+            return true
+        }
+        return false
+    }
+
+    override suspend fun viewers(): List<HumanEntity> {
+        return inventory?.viewers ?: emptyList()
+    }
+
+    override suspend fun contains(client: Client): Boolean {
+        return client.player?.let { it in viewers() } == true
+    }
+
+    override fun close() {
+        super.close()
+        inventory?.close()
+        inventory = null
+    }
+
+    /**
+     * Fill the inventory with items for the client.
+     * This function is called when the inventory is created.
+     * @param inventory The inventory to fill.
+     */
+    protected abstract suspend fun fill(inventory: Inventory)
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt
new file mode 100644
index 00000000..3c76e379
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt
@@ -0,0 +1,45 @@
+package com.github.rushyverse.api.listener
+
+import com.github.rushyverse.api.koin.inject
+import com.github.rushyverse.api.player.ClientManager
+import org.bukkit.entity.HumanEntity
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.event.player.PlayerQuitEvent
+
+public class GUIListener : Listener {
+
+    private val clients: ClientManager by inject()
+
+    @EventHandler
+    public suspend fun onInventoryClick(event: InventoryClickEvent) {
+        val item = event.currentItem ?: return
+        val player = event.whoClicked
+        val client = clients.getClient(player)
+        client.gui()?.onClick(client, item, event)
+    }
+
+    @EventHandler
+    public suspend fun onInventoryClose(event: InventoryCloseEvent) {
+        val player = event.player
+        quitOpenedGUI(player)
+    }
+
+    @EventHandler
+    public suspend fun onPlayerQuit(event: PlayerQuitEvent) {
+        quitOpenedGUI(event.player)
+    }
+
+    /**
+     * Quit the opened GUI for the player.
+     * @param player Player to quit the GUI for.
+     */
+    private suspend fun quitOpenedGUI(player: HumanEntity) {
+        clients.getClientOrNull(player)?.let {
+            it.gui()?.close(it)
+        }
+    }
+
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/Client.kt b/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
index 0127a2d3..b8cc4838 100644
--- a/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
@@ -2,8 +2,10 @@ package com.github.rushyverse.api.player
 
 import com.github.rushyverse.api.delegate.DelegatePlayer
 import com.github.rushyverse.api.extension.asComponent
+import com.github.rushyverse.api.gui.GUI
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.exception.PlayerNotFoundException
+import com.github.rushyverse.api.player.gui.GUIManager
 import com.github.rushyverse.api.player.language.LanguageManager
 import com.github.rushyverse.api.player.scoreboard.ScoreboardManager
 import com.github.rushyverse.api.translation.SupportedLanguage
@@ -28,6 +30,8 @@ public open class Client(
 
     private val languageManager: LanguageManager by inject()
 
+    private val guiManager: GUIManager by inject()
+
     public val player: Player? by DelegatePlayer(playerUUID)
 
     /**
@@ -60,7 +64,6 @@ public open class Client(
         send(message.asComponent())
     }
 
-
     /**
      * Retrieve the scoreboard of the player.
      * The scoreboard will be created if it doesn't exist.
@@ -74,4 +77,10 @@ public open class Client(
      */
     public suspend fun lang(): SupportedLanguage = languageManager.get(requirePlayer())
 
+    /**
+     * Get the opened GUI of the player.
+     * @return The opened GUI of the player.
+     */
+    public suspend fun gui(): GUI? = guiManager.get(this)
+
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt b/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt
index 0c88e8a6..dd00fe52 100644
--- a/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt
@@ -1,13 +1,16 @@
 package com.github.rushyverse.api.player
 
-import org.bukkit.entity.Player
+import com.github.rushyverse.api.player.exception.ClientNotFoundException
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.bukkit.entity.HumanEntity
 
 /**
  * Get a client from the player instance.
  * @param player Player.
  * @return The client linked to a player.
  */
-public suspend inline fun <reified T : Client> ClientManager.getTypedClient(player: Player): T = getClient(player) as T
+public suspend inline fun <reified T : Client> ClientManager.getTypedClient(player: HumanEntity): T = getClient(player) as T
 
 /**
  * Get a client from the key linked to a player.
@@ -21,7 +24,7 @@ public suspend inline fun <reified T : Client> ClientManager.getTypedClient(key:
  * @param player Player.
  * @return The client linked to a player, `null` if not found.
  */
-public suspend inline fun <reified T : Client> ClientManager.getTypedClientOrNull(player: Player): T? =
+public suspend inline fun <reified T : Client> ClientManager.getTypedClientOrNull(player: HumanEntity): T? =
     getClientOrNull(player) as T?
 
 /**
@@ -45,28 +48,28 @@ public interface ClientManager {
      * @param client New client added.
      * @return The previous value associated with a key, or null there is none.
      */
-    public suspend fun put(player: Player, client: Client): Client?
+    public suspend fun put(player: HumanEntity, client: Client): Client?
 
     /**
      * Put a new client in the server if no client is linked to the player.
      * @param client New client added.
      * @return The previous value associated with a key, or null there is none.
      */
-    public suspend fun putIfAbsent(player: Player, client: Client): Client?
+    public suspend fun putIfAbsent(player: HumanEntity, client: Client): Client?
 
     /**
      * Remove a client from the server by a Player.
      * @param player Player linked to a Client.
      * @return The client that was removed null otherwise.
      */
-    public suspend fun removeClient(player: Player): Client?
+    public suspend fun removeClient(player: HumanEntity): Client?
 
     /**
      * Get a client from the player instance.
      * @param player Player.
      * @return The client linked to a player.
      */
-    public suspend fun getClient(player: Player): Client
+    public suspend fun getClient(player: HumanEntity): Client
 
     /**
      * Get a client from the key linked to a player.
@@ -80,7 +83,7 @@ public interface ClientManager {
      * @param player Player.
      * @return The client linked to a player, `null` if not found.
      */
-    public suspend fun getClientOrNull(player: Player): Client?
+    public suspend fun getClientOrNull(player: HumanEntity): Client?
 
     /**
      * Get a client from the key linked to a player.
@@ -94,5 +97,63 @@ public interface ClientManager {
      * @param player Player.
      * @return `true` if there is a client for the player, `false` otherwise.
      */
-    public suspend fun contains(player: Player): Boolean
+    public suspend fun contains(player: HumanEntity): Boolean
+}
+
+/**
+ * Manage the existing client present in the server.
+ * The clients are stored with the name of the player.
+ * @property _clients Synchronized mutable map of clients as value and name of player as a key.
+ */
+public class ClientManagerImpl : ClientManager {
+
+    private val mutex = Mutex()
+
+    /**
+     * All clients in server linked by the name of player.
+     */
+    private val _clients = mutableMapOf<String, Client>()
+
+    override val clients: Map<String, Client> = _clients
+
+    override suspend fun put(
+        player: HumanEntity,
+        client: Client
+    ): Client? = mutex.withLock {
+        _clients.put(player.name, client)
+    }
+
+    override suspend fun putIfAbsent(
+        player: HumanEntity,
+        client: Client
+    ): Client? = mutex.withLock {
+        _clients.putIfAbsent(getKey(player), client)
+    }
+
+    override suspend fun removeClient(player: HumanEntity): Client? = mutex.withLock {
+        _clients.remove(getKey(player))
+    }
+
+    override suspend fun getClient(player: HumanEntity): Client = getClient(getKey(player))
+
+    override suspend fun getClient(key: String): Client =
+        getClientOrNull(key) ?: throw ClientNotFoundException("No client is linked to the name [$key]")
+
+    override suspend fun getClientOrNull(player: HumanEntity): Client? = getClientOrNull(getKey(player))
+
+    override suspend fun getClientOrNull(key: String): Client? = mutex.withLock {
+        _clients[key]
+    }
+
+    /**
+     * Key use for the Map
+     * @param p Player that has the key
+     * @return The key for the Map
+     */
+    private fun getKey(p: HumanEntity): String = p.name
+
+    override suspend fun contains(player: HumanEntity): Boolean = mutex.withLock {
+        _clients.containsKey(getKey(player))
+    }
+
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/ClientManagerImpl.kt b/src/main/kotlin/com/github/rushyverse/api/player/ClientManagerImpl.kt
deleted file mode 100644
index 23aa19de..00000000
--- a/src/main/kotlin/com/github/rushyverse/api/player/ClientManagerImpl.kt
+++ /dev/null
@@ -1,64 +0,0 @@
-package com.github.rushyverse.api.player
-
-import com.github.rushyverse.api.player.exception.ClientNotFoundException
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import org.bukkit.entity.Player
-
-/**
- * Manage the existing client present in the server.
- * The clients are stored with the name of the player.
- * @property _clients Synchronized mutable map of clients as value and name of player as a key.
- */
-public class ClientManagerImpl : ClientManager {
-
-    private val mutex = Mutex()
-
-    /**
-     * All clients in server linked by the name of player.
-     */
-    private val _clients = mutableMapOf<String, Client>()
-
-    override val clients: Map<String, Client> = _clients
-
-    override suspend fun put(
-        player: Player,
-        client: Client
-    ): Client? = mutex.withLock {
-        _clients.put(player.name, client)
-    }
-
-    override suspend fun putIfAbsent(
-        player: Player,
-        client: Client
-    ): Client? = mutex.withLock {
-        _clients.putIfAbsent(getKey(player), client)
-    }
-
-    override suspend fun removeClient(player: Player): Client? = mutex.withLock {
-        _clients.remove(getKey(player))
-    }
-
-    override suspend fun getClient(player: Player): Client = getClient(getKey(player))
-
-    override suspend fun getClient(key: String): Client =
-        getClientOrNull(key) ?: throw ClientNotFoundException("No client is linked to the name [$key]")
-
-    override suspend fun getClientOrNull(player: Player): Client? = getClientOrNull(getKey(player))
-
-    override suspend fun getClientOrNull(key: String): Client? = mutex.withLock {
-        _clients[key]
-    }
-
-    /**
-     * Key use for the Map
-     * @param p Player that has the key
-     * @return The key for the Map
-     */
-    private fun getKey(p: Player): String = p.name
-
-    override suspend fun contains(player: Player): Boolean = mutex.withLock {
-        _clients.containsKey(getKey(player))
-    }
-
-}
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt b/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt
new file mode 100644
index 00000000..7ffecc6e
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt
@@ -0,0 +1,58 @@
+package com.github.rushyverse.api.player.gui
+
+import com.github.rushyverse.api.gui.GUI
+import com.github.rushyverse.api.player.Client
+import kotlinx.coroutines.sync.Mutex
+
+/**
+ * Manages the GUIs for players within the game.
+ * This class ensures thread-safe operations on the GUIs by using mutex locks.
+ */
+public class GUIManager {
+
+    /**
+     * Mutex used to ensure thread-safe operations.
+     */
+    private val mutex = Mutex()
+
+    /**
+     * Private mutable set storing GUIs.
+     */
+    private val _guis = mutableSetOf<GUI>()
+
+    /**
+     * Immutable view of the GUIs set.
+     */
+    public val guis: Set<GUI> = _guis
+
+    /**
+     * Retrieves the GUI for the specified player.
+     * This function is thread-safe and uses mutex locks to ensure atomic operations.
+     *
+     * @param client The player for whom the GUI is to be retrieved or created.
+     * @return The language associated with the player.
+     */
+    public suspend fun get(client: Client): GUI? {
+        return _guis.firstOrNull { it.contains(client) }
+    }
+
+    /**
+     * Add a GUI to the listener.
+     * @param gui GUI to add.
+     * @return True if the GUI was added, false otherwise.
+     */
+    public fun add(gui: GUI): Boolean {
+        return _guis.add(gui)
+    }
+
+    /**
+     * Remove a GUI from the listener.
+     * @param gui GUI to remove.
+     * @return True if the GUI was removed, false otherwise.
+     */
+    public fun remove(gui: GUI): Boolean {
+        return _guis.remove(gui)
+    }
+
+
+}

From 9431249330741a2cfe075fbd21cfd2c88d126cc4 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 14 Dec 2023 14:53:20 +0100
Subject: [PATCH 02/50] chore: Remove unused property

---
 src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt  | 1 -
 .../com/github/rushyverse/api/player/gui/GUIManager.kt      | 6 ------
 2 files changed, 7 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index b984da53..0bb0c84c 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -12,7 +12,6 @@ import org.bukkit.inventory.Inventory
  * @property inventoryType Type of the inventory.
  * @property title Title of the inventory.
  * @property server Server
- * @property listener Listener to listen to the clicks on the inventory.
  * @property viewers List of viewers.
  * @property inventory Inventory shared by all the viewers.
  */
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt b/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt
index 7ffecc6e..c390a91c 100644
--- a/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt
@@ -2,7 +2,6 @@ package com.github.rushyverse.api.player.gui
 
 import com.github.rushyverse.api.gui.GUI
 import com.github.rushyverse.api.player.Client
-import kotlinx.coroutines.sync.Mutex
 
 /**
  * Manages the GUIs for players within the game.
@@ -10,11 +9,6 @@ import kotlinx.coroutines.sync.Mutex
  */
 public class GUIManager {
 
-    /**
-     * Mutex used to ensure thread-safe operations.
-     */
-    private val mutex = Mutex()
-
     /**
      * Private mutable set storing GUIs.
      */

From a960c1196790c34afa16ad2f29635c366724c2a9 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 14 Dec 2023 18:15:46 +0100
Subject: [PATCH 03/50] fix: Stack overflow when close gui

---
 build.gradle.kts                              | 11 +++
 gradle/wrapper/gradle-wrapper.properties      |  2 +-
 .../com/github/rushyverse/api/APIPlugin.kt    |  2 +
 .../com/github/rushyverse/api/Plugin.kt       | 15 +++-
 .../com/github/rushyverse/api/gui/GUI.kt      | 16 +++--
 .../github/rushyverse/api/gui/GUIListener.kt  | 72 +++++++++++++++++++
 .../api/{player => }/gui/GUIManager.kt        |  5 +-
 .../github/rushyverse/api/gui/PersonalGUI.kt  |  9 ++-
 .../github/rushyverse/api/gui/SharedGUI.kt    |  7 +-
 .../rushyverse/api/listener/GUIListener.kt    | 45 ------------
 .../github/rushyverse/api/player/Client.kt    |  4 +-
 .../rushyverse/api/player/ClientManager.kt    |  3 +-
 12 files changed, 124 insertions(+), 67 deletions(-)
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
 rename src/main/kotlin/com/github/rushyverse/api/{player => }/gui/GUIManager.kt (93%)
 delete mode 100644 src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt

diff --git a/build.gradle.kts b/build.gradle.kts
index b22c5bcc..153f3e40 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,3 +1,4 @@
+import io.gitlab.arturbosch.detekt.Detekt
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -130,6 +131,16 @@ tasks {
         targetCompatibility = javaVersionString
     }
 
+    withType<Detekt>().configureEach {
+        reports {
+            html.required.set(true)
+            xml.required.set(true)
+            txt.required.set(false)
+            sarif.required.set(false)
+            md.required.set(false)
+        }
+    }
+
     test {
         useJUnitPlatform()
     }
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index c9eb15be..a5952066 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-rc-1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
index 2bb5d419..e1b0480e 100644
--- a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
@@ -2,6 +2,7 @@ package com.github.rushyverse.api
 
 import com.github.rushyverse.api.extension.registerListener
 import com.github.rushyverse.api.game.SharedGameData
+import com.github.rushyverse.api.gui.GUIManager
 import com.github.rushyverse.api.koin.CraftContext
 import com.github.rushyverse.api.koin.loadModule
 import com.github.rushyverse.api.listener.api.LanguageListener
@@ -37,6 +38,7 @@ public class APIPlugin : JavaPlugin() {
             single { ScoreboardManager() }
             single { LanguageManager() }
             single { SharedGameData() }
+            single { GUIManager() }
         }
 
         registerListener { LanguageListener() }
diff --git a/src/main/kotlin/com/github/rushyverse/api/Plugin.kt b/src/main/kotlin/com/github/rushyverse/api/Plugin.kt
index 31d770e5..58315a14 100644
--- a/src/main/kotlin/com/github/rushyverse/api/Plugin.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/Plugin.kt
@@ -7,6 +7,7 @@ import com.github.rushyverse.api.configuration.reader.IFileReader
 import com.github.rushyverse.api.configuration.reader.YamlFileReader
 import com.github.rushyverse.api.extension.asComponent
 import com.github.rushyverse.api.extension.registerListener
+import com.github.rushyverse.api.gui.GUIListener
 import com.github.rushyverse.api.koin.CraftContext
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.koin.loadModule
@@ -16,11 +17,21 @@ import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
 import com.github.rushyverse.api.player.language.LanguageManager
-import com.github.rushyverse.api.serializer.*
+import com.github.rushyverse.api.serializer.ComponentSerializer
+import com.github.rushyverse.api.serializer.DyeColorSerializer
+import com.github.rushyverse.api.serializer.EnchantmentSerializer
+import com.github.rushyverse.api.serializer.ItemStackSerializer
+import com.github.rushyverse.api.serializer.LocationSerializer
+import com.github.rushyverse.api.serializer.MaterialSerializer
+import com.github.rushyverse.api.serializer.NamespacedSerializer
+import com.github.rushyverse.api.serializer.PatternSerializer
+import com.github.rushyverse.api.serializer.PatternTypeSerializer
+import com.github.rushyverse.api.serializer.RangeDoubleSerializer
 import com.github.rushyverse.api.translation.ResourceBundleTranslator
 import com.github.rushyverse.api.translation.Translator
 import com.github.rushyverse.api.translation.registerResourceBundleForSupportedLocales
 import com.github.shynixn.mccoroutine.bukkit.SuspendingJavaPlugin
+import java.util.*
 import kotlinx.serialization.modules.SerializersModule
 import kotlinx.serialization.modules.SerializersModuleBuilder
 import kotlinx.serialization.modules.contextual
@@ -29,7 +40,6 @@ import org.bukkit.entity.Player
 import org.jetbrains.annotations.Blocking
 import org.koin.core.module.Module
 import org.koin.dsl.bind
-import java.util.*
 
 /**
  * Represents the base functionality required to create a plugin.
@@ -70,6 +80,7 @@ public abstract class Plugin(
 
         registerListener { PlayerListener(this) }
         registerListener { VillagerListener(this) }
+        registerListener { GUIListener(this) }
     }
 
     /**
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index c60c3f4b..6c6fada8 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -2,7 +2,6 @@ package com.github.rushyverse.api.gui
 
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.Client
-import com.github.rushyverse.api.player.gui.GUIManager
 import java.io.Closeable
 import org.bukkit.Server
 import org.bukkit.entity.HumanEntity
@@ -15,9 +14,9 @@ import org.bukkit.inventory.ItemStack
  * Only one inventory is created for all the viewers.
  * @property server Server.
  * @property manager Manager to register or unregister the GUI.
- * @property viewers List of viewers.
+ * @property isClosed If true, the GUI is closed; otherwise it is open.
  */
-public abstract class GUI: Closeable {
+public abstract class GUI : Closeable {
 
     protected val server: Server by inject()
 
@@ -25,6 +24,10 @@ public abstract class GUI: Closeable {
 
     public var isClosed: Boolean = false
 
+    init {
+        register()
+    }
+
     /**
      * Create the inventory of the GUI.
      * @return The inventory of the GUI.
@@ -46,11 +49,12 @@ public abstract class GUI: Closeable {
     public abstract suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent)
 
     /**
-     * Close the inventory for the player.
-     * @param client Client to close the inventory for.
+     * Remove the client has a viewer of the GUI.
+     * @param client Client to close the GUI for.
+     * @param closeInventory If true, the interface will be closed, otherwise it will be kept open.
      * @return True if the inventory was closed, false otherwise.
      */
-    public abstract suspend fun close(client: Client): Boolean
+    public abstract suspend fun close(client: Client, closeInventory: Boolean = true): Boolean
 
     /**
      * Close the inventory.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
new file mode 100644
index 00000000..63c83452
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
@@ -0,0 +1,72 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.Plugin
+import com.github.rushyverse.api.extension.event.cancel
+import com.github.rushyverse.api.koin.inject
+import com.github.rushyverse.api.player.ClientManager
+import org.bukkit.entity.HumanEntity
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.event.player.PlayerQuitEvent
+
+/**
+ * Listener for GUI events.
+ * @property clients Manager of clients.
+ */
+public class GUIListener(plugin: Plugin) : Listener {
+
+    private val clients: ClientManager by inject(plugin.id)
+
+    /**
+     * Called when a player clicks on an item in an inventory.
+     * If the click is detected in a GUI, the event is cancelled and the GUI is notified.
+     * @param event Event of the click.
+     */
+    @EventHandler
+    public suspend fun onInventoryClick(event: InventoryClickEvent) {
+        if (event.isCancelled) return
+        val item = event.currentItem ?: return
+        val player = event.whoClicked
+
+        val client = clients.getClient(player)
+        val gui = client.gui() ?: return
+
+        // The item in a GUI is not supposed to be moved
+        event.cancel()
+        gui.onClick(client, item, event)
+    }
+
+    /**
+     * Called when a player closes an inventory.
+     * If the inventory is a GUI, the GUI is notified that it is closed for this player.
+     * @param event Event of the close.
+     */
+    @EventHandler
+    public suspend fun onInventoryClose(event: InventoryCloseEvent) {
+        quitOpenedGUI(event.player)
+    }
+
+    /**
+     * Called when a player quits the server.
+     * If the player has a GUI opened, the GUI is notified that it is closed for this player.
+     * @param event Event of the quit.
+     */
+    @EventHandler
+    public suspend fun onPlayerQuit(event: PlayerQuitEvent) {
+        quitOpenedGUI(event.player)
+    }
+
+    /**
+     * Quit the opened GUI for the player.
+     * @param player Player to quit the GUI for.
+     */
+    private suspend fun quitOpenedGUI(player: HumanEntity) {
+        val client = clients.getClientOrNull(player)
+        val gui = client?.gui() ?: return
+        // We don't close the inventory because it is closing due to event.
+        gui.close(client, false)
+    }
+
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
similarity index 93%
rename from src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt
rename to src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
index c390a91c..0f523eda 100644
--- a/src/main/kotlin/com/github/rushyverse/api/player/gui/GUIManager.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
@@ -1,6 +1,5 @@
-package com.github.rushyverse.api.player.gui
+package com.github.rushyverse.api.gui
 
-import com.github.rushyverse.api.gui.GUI
 import com.github.rushyverse.api.player.Client
 
 /**
@@ -47,6 +46,4 @@ public class GUIManager {
     public fun remove(gui: GUI): Boolean {
         return _guis.remove(gui)
     }
-
-
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index a2a7ca06..0f7118ab 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -57,8 +57,13 @@ public abstract class PersonalGUI(
      */
     protected abstract suspend fun fill(client: Client, inventory: Inventory)
 
-    override suspend fun close(client: Client): Boolean {
-        return mutex.withLock { inventories.remove(client) }?.close() == 1
+    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+        return mutex.withLock { inventories.remove(client) }?.run {
+            if (closeInventory) {
+                close()
+            }
+            true
+        } == true
     }
 
     override suspend fun viewers(): List<HumanEntity> {
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index 0bb0c84c..4e701a09 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -18,7 +18,7 @@ import org.bukkit.inventory.Inventory
 public abstract class SharedGUI(
     public val inventoryType: InventoryType,
     public val title: Component
-): GUI() {
+) : GUI() {
 
     private var inventory: Inventory? = null
 
@@ -43,13 +43,12 @@ public abstract class SharedGUI(
 
         return inventory ?: createInventory(client).also {
             inventory = it
-            register()
         }
     }
 
-    override suspend fun close(client: Client): Boolean {
+    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
         val player = client.requirePlayer()
-        if(player.openInventory.topInventory == inventory) {
+        if (closeInventory && player.openInventory.topInventory == inventory) {
             player.closeInventory()
             return true
         }
diff --git a/src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt
deleted file mode 100644
index 3c76e379..00000000
--- a/src/main/kotlin/com/github/rushyverse/api/listener/GUIListener.kt
+++ /dev/null
@@ -1,45 +0,0 @@
-package com.github.rushyverse.api.listener
-
-import com.github.rushyverse.api.koin.inject
-import com.github.rushyverse.api.player.ClientManager
-import org.bukkit.entity.HumanEntity
-import org.bukkit.event.EventHandler
-import org.bukkit.event.Listener
-import org.bukkit.event.inventory.InventoryClickEvent
-import org.bukkit.event.inventory.InventoryCloseEvent
-import org.bukkit.event.player.PlayerQuitEvent
-
-public class GUIListener : Listener {
-
-    private val clients: ClientManager by inject()
-
-    @EventHandler
-    public suspend fun onInventoryClick(event: InventoryClickEvent) {
-        val item = event.currentItem ?: return
-        val player = event.whoClicked
-        val client = clients.getClient(player)
-        client.gui()?.onClick(client, item, event)
-    }
-
-    @EventHandler
-    public suspend fun onInventoryClose(event: InventoryCloseEvent) {
-        val player = event.player
-        quitOpenedGUI(player)
-    }
-
-    @EventHandler
-    public suspend fun onPlayerQuit(event: PlayerQuitEvent) {
-        quitOpenedGUI(event.player)
-    }
-
-    /**
-     * Quit the opened GUI for the player.
-     * @param player Player to quit the GUI for.
-     */
-    private suspend fun quitOpenedGUI(player: HumanEntity) {
-        clients.getClientOrNull(player)?.let {
-            it.gui()?.close(it)
-        }
-    }
-
-}
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/Client.kt b/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
index b8cc4838..bb6ff06f 100644
--- a/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
@@ -3,18 +3,18 @@ package com.github.rushyverse.api.player
 import com.github.rushyverse.api.delegate.DelegatePlayer
 import com.github.rushyverse.api.extension.asComponent
 import com.github.rushyverse.api.gui.GUI
+import com.github.rushyverse.api.gui.GUIManager
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.exception.PlayerNotFoundException
-import com.github.rushyverse.api.player.gui.GUIManager
 import com.github.rushyverse.api.player.language.LanguageManager
 import com.github.rushyverse.api.player.scoreboard.ScoreboardManager
 import com.github.rushyverse.api.translation.SupportedLanguage
 import fr.mrmicky.fastboard.adventure.FastBoard
+import java.util.*
 import kotlinx.coroutines.CoroutineScope
 import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver
 import org.bukkit.entity.Player
-import java.util.*
 
 /**
  * Client to store and manage data about player.
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt b/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt
index dd00fe52..6835f1d6 100644
--- a/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/player/ClientManager.kt
@@ -10,7 +10,8 @@ import org.bukkit.entity.HumanEntity
  * @param player Player.
  * @return The client linked to a player.
  */
-public suspend inline fun <reified T : Client> ClientManager.getTypedClient(player: HumanEntity): T = getClient(player) as T
+public suspend inline fun <reified T : Client> ClientManager.getTypedClient(player: HumanEntity): T =
+    getClient(player) as T
 
 /**
  * Get a client from the key linked to a player.

From c532cf8e998f2ceb41a0e3252270d464e70bc39b Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 14 Dec 2023 19:29:55 +0100
Subject: [PATCH 04/50] fix: Add way to create inventory from scratch

---
 .../com/github/rushyverse/api/gui/GUI.kt      |  1 +
 .../github/rushyverse/api/gui/PersonalGUI.kt  | 20 +++++++++-----
 .../github/rushyverse/api/gui/SharedGUI.kt    | 27 ++++++++++---------
 3 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 6c6fada8..ee6c0682 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -23,6 +23,7 @@ public abstract class GUI : Closeable {
     private val manager: GUIManager by inject()
 
     public var isClosed: Boolean = false
+        protected set
 
     init {
         register()
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 0f7118ab..749989d1 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -6,20 +6,19 @@ import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.translation.Translator
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import net.kyori.adventure.text.Component
 import org.bukkit.entity.HumanEntity
+import org.bukkit.entity.Player
 import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.InventoryHolder
 
 /**
  * GUI where a new inventory is created for each viewer.
- * @property inventoryType InventoryType
  * @property title String
  * @property translator Translator
  */
-public abstract class PersonalGUI(
-    public val inventoryType: InventoryType,
-    public val title: String
-) : GUI() {
+public abstract class PersonalGUI(public val title: String) : GUI() {
 
     private val translator: Translator by inject()
 
@@ -44,11 +43,20 @@ public abstract class PersonalGUI(
     override suspend fun createInventory(client: Client): Inventory {
         val player = client.requirePlayer()
         val translatedTitle = title.toTranslatedComponent(translator, client.lang().locale)
-        return server.createInventory(player, inventoryType, translatedTitle).also {
+        return createInventory(player, translatedTitle).also {
             fill(client, it)
         }
     }
 
+    /**
+     * Create the inventory for the client.
+     * This function is called when the [owner] wants to open the inventory.
+     * @param owner Player who wants to open the inventory.
+     * @param title Translated title of the inventory.
+     * @return The inventory for the client.
+     */
+    protected abstract fun createInventory(owner: InventoryHolder, title: Component): Inventory
+
     /**
      * Fill the inventory with items for the client.
      * This function is called when the inventory is created.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index 4e701a09..97fe5020 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -5,29 +5,19 @@ import net.kyori.adventure.text.Component
 import org.bukkit.entity.HumanEntity
 import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.InventoryHolder
 
 /**
  * GUI that can be shared by multiple players.
  * Only one inventory is created for all the viewers.
- * @property inventoryType Type of the inventory.
- * @property title Title of the inventory.
  * @property server Server
  * @property viewers List of viewers.
  * @property inventory Inventory shared by all the viewers.
  */
-public abstract class SharedGUI(
-    public val inventoryType: InventoryType,
-    public val title: Component
-) : GUI() {
+public abstract class SharedGUI : GUI() {
 
     private var inventory: Inventory? = null
 
-    override suspend fun createInventory(client: Client): Inventory {
-        return server.createInventory(null, inventoryType, title).also {
-            fill(it)
-        }
-    }
-
     public override suspend fun open(client: Client) {
         val inventory = getOrCreateInventory(client)
         client.requirePlayer().openInventory(inventory)
@@ -46,6 +36,19 @@ public abstract class SharedGUI(
         }
     }
 
+    override suspend fun createInventory(client: Client): Inventory {
+        return createInventory().also {
+            fill(it)
+        }
+    }
+
+    /**
+     * Create the inventory of the GUI.
+     * This function is called only once when the inventory is created.
+     * @return A new inventory.
+     */
+    protected abstract fun createInventory(): Inventory
+
     override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
         val player = client.requirePlayer()
         if (closeInventory && player.openInventory.topInventory == inventory) {

From 0fc9c1476b0b65244aecff4741e3025613dc3e14 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 14 Dec 2023 19:32:16 +0100
Subject: [PATCH 05/50] fix: Use requireOpen function

---
 src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt | 1 -
 src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt   | 3 +--
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 749989d1..80761d60 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -28,7 +28,6 @@ public abstract class PersonalGUI(public val title: String) : GUI() {
 
     override suspend fun open(client: Client) {
         requireOpen()
-
         val inventory = createInventory(client)
 
         mutex.withLock {
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index 97fe5020..6df1ccf0 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -29,8 +29,7 @@ public abstract class SharedGUI : GUI() {
      * @return The inventory of the GUI.
      */
     private suspend fun getOrCreateInventory(client: Client): Inventory {
-        require(!isClosed) { "The GUI is closed" }
-
+        requireOpen()
         return inventory ?: createInventory(client).also {
             inventory = it
         }

From 74cd7045c83c02b092aa9940a6cd5145e477d874 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 14 Dec 2023 19:33:03 +0100
Subject: [PATCH 06/50] chore: Format

---
 src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt | 2 --
 src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt   | 3 ---
 2 files changed, 5 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 80761d60..30007e8e 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -8,8 +8,6 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import net.kyori.adventure.text.Component
 import org.bukkit.entity.HumanEntity
-import org.bukkit.entity.Player
-import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.InventoryHolder
 
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index 6df1ccf0..3a23d61a 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -1,11 +1,8 @@
 package com.github.rushyverse.api.gui
 
 import com.github.rushyverse.api.player.Client
-import net.kyori.adventure.text.Component
 import org.bukkit.entity.HumanEntity
-import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.Inventory
-import org.bukkit.inventory.InventoryHolder
 
 /**
  * GUI that can be shared by multiple players.

From 96d23fb16696bf4c69dd79be26dea6250f18446a Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 14 Dec 2023 19:36:47 +0100
Subject: [PATCH 07/50] fix: Change scope property

---
 src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 30007e8e..959fb6bb 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -18,7 +18,7 @@ import org.bukkit.inventory.InventoryHolder
  */
 public abstract class PersonalGUI(public val title: String) : GUI() {
 
-    private val translator: Translator by inject()
+    protected val translator: Translator by inject()
 
     private var inventories: MutableMap<Client, Inventory> = mutableMapOf()
 

From 85c1f89c4c3a94c56a21af8cf199e1ff91928988 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 09:35:49 +0100
Subject: [PATCH 08/50] fix: Safe open by multiple check

---
 .../com/github/rushyverse/api/gui/GUI.kt      |  36 ++++-
 .../github/rushyverse/api/gui/GUIManager.kt   |   2 +-
 .../github/rushyverse/api/gui/PersonalGUI.kt  |  26 ++--
 .../github/rushyverse/api/gui/SharedGUI.kt    |  19 +--
 .../rushyverse/api/gui/GUIManagerTest.kt      | 131 ++++++++++++++++++
 .../rushyverse/api/player/ClientTest.kt       |  88 +++++++++---
 6 files changed, 252 insertions(+), 50 deletions(-)
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index ee6c0682..dafb3f9b 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -3,12 +3,14 @@ package com.github.rushyverse.api.gui
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.Client
 import java.io.Closeable
+import mu.KotlinLogging
 import org.bukkit.Server
 import org.bukkit.entity.HumanEntity
 import org.bukkit.event.inventory.InventoryClickEvent
-import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 
+private val logger = KotlinLogging.logger {}
+
 /**
  * GUI that can be shared by multiple players.
  * Only one inventory is created for all the viewers.
@@ -30,16 +32,36 @@ public abstract class GUI : Closeable {
     }
 
     /**
-     * Create the inventory of the GUI.
-     * @return The inventory of the GUI.
+     * Open the GUI for the client only if the GUI is not closed.
+     * If the client has another GUI opened, close it.
+     * If the client has the same GUI opened, do nothing.
+     * @param client Client to open the GUI for.
      */
-    protected abstract suspend fun createInventory(client: Client): Inventory
+    public suspend fun open(client: Client) {
+        requireOpen()
+
+        val gui = client.gui()
+        if (gui == this) return
+        // If the client has another GUI opened, close it.
+        gui?.close(client, true)
+
+        val player = client.player
+        if (player == null) {
+            logger.warn { "Cannot open inventory for player ${client.playerUUID}: player is null" }
+            return
+        }
+        // If the player is dead, do not open the GUI because the interface cannot be shown to the player.
+        if (player.isDead) return
+
+        openGUI(client)
+    }
 
     /**
-     * Open the inventory for the player.
-     * @param client Client to open the inventory for.
+     * Open the GUI for the client.
+     * Called by [open] after all the checks.
+     * @param client Client to open the GUI for.
      */
-    public abstract suspend fun open(client: Client)
+    protected abstract suspend fun openGUI(client: Client)
 
     /**
      * Action to do when the client clicks on an item in the inventory.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
index 0f523eda..f110d828 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
@@ -16,7 +16,7 @@ public class GUIManager {
     /**
      * Immutable view of the GUIs set.
      */
-    public val guis: Set<GUI> = _guis
+    public val guis: Collection<GUI> get() = _guis
 
     /**
      * Retrieves the GUI for the specified player.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 959fb6bb..598849cd 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -13,8 +13,8 @@ import org.bukkit.inventory.InventoryHolder
 
 /**
  * GUI where a new inventory is created for each viewer.
- * @property title String
- * @property translator Translator
+ * @property title Title that can be translated.
+ * @property translator Translator to translate the title.
  */
 public abstract class PersonalGUI(public val title: String) : GUI() {
 
@@ -24,20 +24,24 @@ public abstract class PersonalGUI(public val title: String) : GUI() {
 
     private val mutex = Mutex()
 
-    override suspend fun open(client: Client) {
-        requireOpen()
+    override suspend fun openGUI(client: Client) {
         val inventory = createInventory(client)
 
-        mutex.withLock {
-            val oldInventory = inventories[client]
-            inventories[client] = inventory
-            oldInventory
-        }?.close()
+        mutex.withLock { inventories[client] }?.close()
 
-        client.requirePlayer().openInventory(inventory)
+        val player = client.requirePlayer()
+        player.openInventory(inventory)
+
+        mutex.withLock { inventories[client] = inventory }
     }
 
-    override suspend fun createInventory(client: Client): Inventory {
+    /**
+     * Create the inventory for the client.
+     * Will translate the title and fill the inventory.
+     * @param client The client to create the inventory for.
+     * @return The inventory for the client.
+     */
+    private suspend fun createInventory(client: Client): Inventory {
         val player = client.requirePlayer()
         val translatedTitle = title.toTranslatedComponent(translator, client.lang().locale)
         return createInventory(player, translatedTitle).also {
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index 3a23d61a..c023dcb6 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -7,7 +7,7 @@ import org.bukkit.inventory.Inventory
 /**
  * GUI that can be shared by multiple players.
  * Only one inventory is created for all the viewers.
- * @property server Server
+ * @property server Server.
  * @property viewers List of viewers.
  * @property inventory Inventory shared by all the viewers.
  */
@@ -15,9 +15,10 @@ public abstract class SharedGUI : GUI() {
 
     private var inventory: Inventory? = null
 
-    public override suspend fun open(client: Client) {
-        val inventory = getOrCreateInventory(client)
-        client.requirePlayer().openInventory(inventory)
+    override suspend fun openGUI(client: Client) {
+        val player = client.requirePlayer()
+        val inventory = getOrCreateInventory()
+        player.openInventory(inventory)
     }
 
     /**
@@ -25,15 +26,9 @@ public abstract class SharedGUI : GUI() {
      * If the inventory is not created, create it.
      * @return The inventory of the GUI.
      */
-    private suspend fun getOrCreateInventory(client: Client): Inventory {
-        requireOpen()
-        return inventory ?: createInventory(client).also {
+    private suspend fun getOrCreateInventory(): Inventory {
+        return inventory ?: createInventory().also {
             inventory = it
-        }
-    }
-
-    override suspend fun createInventory(client: Client): Inventory {
-        return createInventory().also {
             fill(it)
         }
     }
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt
new file mode 100644
index 00000000..e861e595
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt
@@ -0,0 +1,131 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.player.Client
+import io.kotest.matchers.shouldBe
+import io.mockk.coEvery
+import io.mockk.mockk
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Nested
+
+class GUIManagerTest {
+
+    private lateinit var manager: GUIManager
+
+    @BeforeTest
+    fun onBefore() {
+        manager = GUIManager()
+    }
+
+    @Nested
+    inner class Get {
+
+        @Test
+        fun `should returns null if no GUI is registered`() = runTest {
+            val client = mockk<Client>()
+            manager.get(client) shouldBe null
+        }
+
+        @Test
+        fun `should returns null if no GUI contains the client`() = runTest {
+            val client = mockk<Client>()
+            val gui = mockk<GUI> {
+                coEvery { contains(any()) } returns false
+            }
+            manager.add(gui)
+            manager.get(client) shouldBe null
+        }
+
+        @Test
+        fun `should returns GUI if contains the client`() = runTest {
+            val client = mockk<Client>()
+            val gui = mockk<GUI> {
+                coEvery { contains(client) } returns true
+            }
+            manager.add(gui)
+            manager.get(client) shouldBe gui
+        }
+
+        @Test
+        fun `should returns GUI if contains the asked client`() = runTest {
+            val client = mockk<Client>()
+            val client2 = mockk<Client>()
+            val gui = mockk<GUI> {
+                coEvery { contains(client) } returns true
+                coEvery { contains(client2) } returns false
+            }
+            manager.add(gui)
+            manager.get(client) shouldBe gui
+            manager.get(client2) shouldBe null
+        }
+
+    }
+
+    @Nested
+    inner class Add {
+
+        @Test
+        fun `should add non registered GUI`() {
+            val gui = mockk<GUI>()
+            manager.add(gui) shouldBe true
+            manager.guis.contains(gui) shouldBe true
+            manager.guis.size shouldBe 1
+        }
+
+        @Test
+        fun `should not add registered GUI`() {
+            val gui = mockk<GUI>()
+            manager.add(gui) shouldBe true
+            manager.add(gui) shouldBe false
+            manager.guis.contains(gui) shouldBe true
+            manager.guis.size shouldBe 1
+        }
+
+        @Test
+        fun `should add multiple GUIs`() {
+            val gui1 = mockk<GUI>()
+            val gui2 = mockk<GUI>()
+            manager.add(gui1) shouldBe true
+            manager.add(gui2) shouldBe true
+            manager.guis.contains(gui1) shouldBe true
+            manager.guis.contains(gui2) shouldBe true
+            manager.guis.size shouldBe 2
+        }
+
+    }
+
+    @Nested
+    inner class Remove {
+
+        @Test
+        fun `should remove registered GUI`() {
+            val gui = mockk<GUI>()
+            manager.add(gui) shouldBe true
+            manager.remove(gui) shouldBe true
+            manager.guis.contains(gui) shouldBe false
+            manager.guis.size shouldBe 0
+        }
+
+        @Test
+        fun `should not remove non registered GUI`() {
+            val gui = mockk<GUI>()
+            manager.remove(gui) shouldBe false
+            manager.guis.contains(gui) shouldBe false
+            manager.guis.size shouldBe 0
+        }
+
+        @Test
+        fun `should remove one GUI`() {
+            val gui1 = mockk<GUI>()
+            val gui2 = mockk<GUI>()
+            manager.add(gui1) shouldBe true
+            manager.add(gui2) shouldBe true
+            manager.remove(gui1) shouldBe true
+            manager.guis.contains(gui1) shouldBe false
+            manager.guis.contains(gui2) shouldBe true
+            manager.guis.size shouldBe 1
+        }
+
+    }
+}
diff --git a/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt b/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt
index 554a6237..7d356af7 100644
--- a/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt
@@ -4,17 +4,25 @@ import be.seeseemelk.mockbukkit.MockBukkit
 import be.seeseemelk.mockbukkit.ServerMock
 import be.seeseemelk.mockbukkit.entity.PlayerMock
 import com.github.rushyverse.api.AbstractKoinTest
+import com.github.rushyverse.api.gui.GUI
+import com.github.rushyverse.api.gui.GUIManager
 import com.github.rushyverse.api.player.exception.PlayerNotFoundException
+import io.kotest.matchers.shouldBe
+import io.mockk.coEvery
+import io.mockk.mockk
 import kotlinx.coroutines.CoroutineScope
 import org.junit.jupiter.api.assertThrows
 import java.util.*
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.*
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Nested
 
 class ClientTest : AbstractKoinTest() {
 
     private lateinit var player: PlayerMock
     private lateinit var serverMock: ServerMock
+    private lateinit var guiManager: GUIManager
 
     @BeforeTest
     override fun onBefore() {
@@ -22,6 +30,11 @@ class ClientTest : AbstractKoinTest() {
         serverMock = MockBukkit.mock().apply {
             player = addPlayer()
         }
+        guiManager = GUIManager()
+
+        loadApiTestModule {
+            single { guiManager }
+        }
     }
 
     @AfterTest
@@ -30,29 +43,66 @@ class ClientTest : AbstractKoinTest() {
         super.onAfter()
     }
 
-    @Test
-    fun `retrieve player instance not found returns null`() {
-        val client = Client(UUID.randomUUID(), CoroutineScope(EmptyCoroutineContext))
-        assertNull(client.player)
-    }
+    @Nested
+    inner class GetPlayer {
 
-    @Test
-    fun `retrieve player instance found returns the instance`() {
-        val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
-        assertEquals(player, client.player)
-    }
+        @Test
+        fun `retrieve player instance not found returns null`() {
+            val client = Client(UUID.randomUUID(), CoroutineScope(EmptyCoroutineContext))
+            assertNull(client.player)
+        }
+
+        @Test
+        fun `retrieve player instance found returns the instance`() {
+            val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+            assertEquals(player, client.player)
+        }
+
+        @Test
+        fun `require player instance not found throws an exception`() {
+            val client = Client(UUID.randomUUID(), CoroutineScope(EmptyCoroutineContext))
+            assertThrows<PlayerNotFoundException> {
+                client.requirePlayer()
+            }
+        }
 
-    @Test
-    fun `require player instance not found throws an exception`() {
-        val client = Client(UUID.randomUUID(), CoroutineScope(EmptyCoroutineContext))
-        assertThrows<PlayerNotFoundException> {
-            client.requirePlayer()
+        @Test
+        fun `require player instance found returns the instance`() {
+            val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+            assertEquals(player, client.requirePlayer())
         }
+
     }
 
-    @Test
-    fun `require player instance found returns the instance`() {
-        val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
-        assertEquals(player, client.requirePlayer())
+    @Nested
+    inner class GetGUI  {
+
+        @Test
+        fun `get GUI returns null if no GUI is registered`() = runTest {
+            val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+            client.gui() shouldBe null
+        }
+
+        @Test
+        fun `get GUI returns null if no GUI contains the client`() = runTest {
+            val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+            val gui = mockk<GUI> {
+                coEvery { contains(client) } returns false
+            }
+            guiManager.add(gui)
+            client.gui() shouldBe null
+        }
+
+        @Test
+        fun `get GUI returns GUI if contains the client`() = runTest {
+            val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+            val gui = mockk<GUI> {
+                coEvery { contains(client) } returns true
+            }
+            guiManager.add(gui)
+            client.gui() shouldBe gui
+        }
+
     }
+
 }

From 8b0980df6330de9ce6a6da6b982d7b8d9859c99b Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 12:37:27 +0100
Subject: [PATCH 09/50] test(gui-listener): Begin test about close GUI

---
 .../rushyverse/api/gui/GUIListenerTest.kt     | 123 ++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
new file mode 100644
index 00000000..647ea079
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -0,0 +1,123 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.AbstractKoinTest
+import com.github.rushyverse.api.player.Client
+import com.github.rushyverse.api.player.ClientManager
+import com.github.rushyverse.api.player.ClientManagerImpl
+import com.github.rushyverse.api.utils.randomString
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.every
+import io.mockk.mockk
+import java.util.*
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.test.runTest
+import net.kyori.adventure.text.Component
+import org.bukkit.entity.Player
+import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.event.player.PlayerQuitEvent
+import org.junit.jupiter.api.Nested
+
+class GUIListenerTest : AbstractKoinTest() {
+
+    private lateinit var guiManager: GUIManager
+    private lateinit var clientManager: ClientManager
+    private lateinit var listener: GUIListener
+
+    @BeforeTest
+    override fun onBefore() {
+        super.onBefore()
+        guiManager = GUIManager()
+        clientManager = ClientManagerImpl()
+        listener = GUIListener(plugin)
+
+        loadApiTestModule {
+            single { guiManager }
+            single { clientManager }
+        }
+    }
+
+    @Nested
+    inner class OnInventoryClick {
+
+
+    }
+
+    abstract inner class CloseGUIDuringEvent {
+
+        @Test
+        fun `should do nothing if client doesn't have a GUI opened`() = runTest {
+            val (player, client) = registerPlayer()
+            val gui = registerGUI {
+                coEvery { contains(client) } returns false
+            }
+
+            val event = PlayerQuitEvent(player, Component.empty(), PlayerQuitEvent.QuitReason.DISCONNECTED)
+            listener.onPlayerQuit(event)
+
+            coVerify(exactly = 0) { gui.close(client, any()) }
+        }
+
+        @Test
+        fun `should close the GUI if client has opened one`() = runTest {
+            val (player, client) = registerPlayer()
+            val gui = registerGUI {
+                coEvery { contains(client) } returns true
+                coEvery { close(client, any()) } returns true
+            }
+
+            val gui2 = registerGUI {
+                coEvery { contains(client) } returns false
+            }
+
+            callEvent(player)
+
+            coVerify(exactly = 1) { gui.close(client, false) }
+            coVerify(exactly = 0) { gui2.close(client, any()) }
+        }
+
+        protected abstract suspend fun callEvent(player: Player)
+
+    }
+
+    @Nested
+    inner class OnInventoryClose : CloseGUIDuringEvent() {
+
+        override suspend fun callEvent(player: Player) {
+            val event = mockk<InventoryCloseEvent> {
+                every { getPlayer() } returns player
+            }
+            listener.onInventoryClose(event)
+        }
+    }
+
+    @Nested
+    inner class OnPlayerQuit : CloseGUIDuringEvent() {
+
+        override suspend fun callEvent(player: Player) {
+            val event = mockk<PlayerQuitEvent> {
+                every { getPlayer() } returns player
+            }
+            listener.onPlayerQuit(event)
+        }
+    }
+
+    private suspend fun registerPlayer(): Pair<Player, Client> {
+        val player = mockk<Player> {
+            every { name } returns randomString()
+            every { uniqueId } returns UUID.randomUUID()
+        }
+        val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+        clientManager.put(player, client)
+        return player to client
+    }
+
+    private inline fun registerGUI(block: GUI.() -> Unit): GUI {
+        val gui = mockk<GUI>(block = block)
+        guiManager.add(gui)
+        return gui
+    }
+}

From e058f80949fcd5473518787501bd6f876d68097b Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 12:37:58 +0100
Subject: [PATCH 10/50] chore: Return boolean when open GUI

---
 .../kotlin/com/github/rushyverse/api/gui/GUI.kt    | 14 ++++++++------
 .../com/github/rushyverse/api/gui/PersonalGUI.kt   |  3 ++-
 .../com/github/rushyverse/api/gui/SharedGUI.kt     |  3 ++-
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index dafb3f9b..fbfab1ea 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -36,32 +36,34 @@ public abstract class GUI : Closeable {
      * If the client has another GUI opened, close it.
      * If the client has the same GUI opened, do nothing.
      * @param client Client to open the GUI for.
+     * @return True if the GUI was opened, false otherwise.
      */
-    public suspend fun open(client: Client) {
+    public suspend fun open(client: Client): Boolean {
         requireOpen()
 
         val gui = client.gui()
-        if (gui == this) return
+        if (gui == this) return false
         // If the client has another GUI opened, close it.
         gui?.close(client, true)
 
         val player = client.player
         if (player == null) {
             logger.warn { "Cannot open inventory for player ${client.playerUUID}: player is null" }
-            return
+            return false
         }
         // If the player is dead, do not open the GUI because the interface cannot be shown to the player.
-        if (player.isDead) return
+        if (player.isDead) return false
 
-        openGUI(client)
+        return openGUI(client)
     }
 
     /**
      * Open the GUI for the client.
      * Called by [open] after all the checks.
      * @param client Client to open the GUI for.
+     * @return True if the GUI was opened, false otherwise.
      */
-    protected abstract suspend fun openGUI(client: Client)
+    protected abstract suspend fun openGUI(client: Client): Boolean
 
     /**
      * Action to do when the client clicks on an item in the inventory.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 598849cd..4e24275a 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -24,7 +24,7 @@ public abstract class PersonalGUI(public val title: String) : GUI() {
 
     private val mutex = Mutex()
 
-    override suspend fun openGUI(client: Client) {
+    override suspend fun openGUI(client: Client): Boolean {
         val inventory = createInventory(client)
 
         mutex.withLock { inventories[client] }?.close()
@@ -33,6 +33,7 @@ public abstract class PersonalGUI(public val title: String) : GUI() {
         player.openInventory(inventory)
 
         mutex.withLock { inventories[client] = inventory }
+        return true
     }
 
     /**
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index c023dcb6..fec7407b 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -15,10 +15,11 @@ public abstract class SharedGUI : GUI() {
 
     private var inventory: Inventory? = null
 
-    override suspend fun openGUI(client: Client) {
+    override suspend fun openGUI(client: Client): Boolean {
         val player = client.requirePlayer()
         val inventory = getOrCreateInventory()
         player.openInventory(inventory)
+        return true
     }
 
     /**

From b42ba7c0a99c308bd2610728b5830eb3051164c2 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 14:45:42 +0100
Subject: [PATCH 11/50] test: GUI on click

---
 .../github/rushyverse/api/gui/GUIListener.kt  |  7 +-
 .../rushyverse/api/gui/GUIListenerTest.kt     | 86 +++++++++++++++++++
 2 files changed, 91 insertions(+), 2 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
index 63c83452..f5314c31 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
@@ -4,6 +4,7 @@ import com.github.rushyverse.api.Plugin
 import com.github.rushyverse.api.extension.event.cancel
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.ClientManager
+import org.bukkit.Material
 import org.bukkit.entity.HumanEntity
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
@@ -27,9 +28,11 @@ public class GUIListener(plugin: Plugin) : Listener {
     @EventHandler
     public suspend fun onInventoryClick(event: InventoryClickEvent) {
         if (event.isCancelled) return
-        val item = event.currentItem ?: return
-        val player = event.whoClicked
 
+        val item = event.currentItem
+        if (item == null || item.type == Material.AIR) return
+
+        val player = event.whoClicked
         val client = clients.getClient(player)
         val gui = client.gui() ?: return
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 647ea079..7375d3a0 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -1,6 +1,10 @@
 package com.github.rushyverse.api.gui
 
+import be.seeseemelk.mockbukkit.MockBukkit
+import be.seeseemelk.mockbukkit.ServerMock
 import com.github.rushyverse.api.AbstractKoinTest
+import com.github.rushyverse.api.extension.ItemStack
+import com.github.rushyverse.api.extension.event.cancel
 import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
@@ -9,16 +13,21 @@ import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
+import io.mockk.verify
 import java.util.*
 import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.test.runTest
 import net.kyori.adventure.text.Component
+import org.bukkit.Material
 import org.bukkit.entity.Player
+import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.event.player.PlayerQuitEvent
+import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
 
 class GUIListenerTest : AbstractKoinTest() {
@@ -26,6 +35,7 @@ class GUIListenerTest : AbstractKoinTest() {
     private lateinit var guiManager: GUIManager
     private lateinit var clientManager: ClientManager
     private lateinit var listener: GUIListener
+    private lateinit var serverMock: ServerMock
 
     @BeforeTest
     override fun onBefore() {
@@ -38,11 +48,87 @@ class GUIListenerTest : AbstractKoinTest() {
             single { guiManager }
             single { clientManager }
         }
+
+        serverMock = MockBukkit.mock()
+    }
+
+    @AfterTest
+    override fun onAfter() {
+        super.onAfter()
+        MockBukkit.unmock()
     }
 
     @Nested
     inner class OnInventoryClick {
 
+        @Test
+        fun `should do nothing if event is cancelled`() = runTest {
+            val (player, client) = registerPlayer()
+            val gui = registerGUI {
+                coEvery { contains(client) } returns true
+            }
+
+            callEvent(true, player, ItemStack { type = Material.DIRT })
+            coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+        }
+
+        @Test
+        fun `should do nothing if item is null or air`() = runTest {
+            val (player, client) = registerPlayer()
+            val gui = registerGUI {
+                coEvery { contains(client) } returns true
+            }
+
+            suspend fun callEvent(item: ItemStack?) {
+                val event = callEvent(false, player, item)
+                coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+                verify(exactly = 0) { event.cancel() }
+            }
+
+            callEvent(null)
+            callEvent(ItemStack { type = Material.AIR })
+        }
+
+        @Test
+        fun `should do nothing if client doesn't have a GUI opened`() = runTest {
+            val (player, client) = registerPlayer()
+            val gui = registerGUI {
+                coEvery { contains(client) } returns false
+            }
+
+            callEvent(false, player, ItemStack { type = Material.DIRT })
+            coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+        }
+
+        @Test
+        fun `should call GUI onClick if client has opened one`() = runTest {
+            val (player, client) = registerPlayer()
+            val gui = registerGUI {
+                coEvery { contains(client) } returns true
+                coEvery { onClick(client, any(), any()) } returns Unit
+            }
+
+            val item = ItemStack { type = Material.DIRT }
+            val event = callEvent(false, player, item)
+            coVerify(exactly = 1) { gui.onClick(client, item, event) }
+            verify(exactly = 1) { event.cancel() }
+        }
+
+        private suspend fun callEvent(
+            cancel: Boolean,
+            player: Player,
+            item: ItemStack?
+        ): InventoryClickEvent {
+            val event = mockk<InventoryClickEvent> {
+                every { isCancelled } returns cancel
+                every { whoClicked } returns player
+                every { currentItem } returns item
+                every { cancel() } returns Unit
+            }
+
+            listener.onInventoryClick(event)
+            return event
+        }
 
     }
 

From b613270a697b271d66688d294cf2cb6e95c93661 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 16:13:17 +0100
Subject: [PATCH 12/50] test: Begin test for PersonalGUI close

---
 .../rushyverse/api/gui/GUIListenerTest.kt     |   5 +-
 .../rushyverse/api/gui/PersonalGUITest.kt     | 147 ++++++++++++++++++
 2 files changed, 148 insertions(+), 4 deletions(-)
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 7375d3a0..29772d72 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -192,10 +192,7 @@ class GUIListenerTest : AbstractKoinTest() {
     }
 
     private suspend fun registerPlayer(): Pair<Player, Client> {
-        val player = mockk<Player> {
-            every { name } returns randomString()
-            every { uniqueId } returns UUID.randomUUID()
-        }
+        val player = serverMock.addPlayer()
         val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
         clientManager.put(player, client)
         return player to client
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
new file mode 100644
index 00000000..6ad873d7
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
@@ -0,0 +1,147 @@
+package com.github.rushyverse.api.gui
+
+import be.seeseemelk.mockbukkit.MockBukkit
+import be.seeseemelk.mockbukkit.ServerMock
+import be.seeseemelk.mockbukkit.entity.PlayerMock
+import com.github.rushyverse.api.AbstractKoinTest
+import com.github.rushyverse.api.player.Client
+import com.github.rushyverse.api.player.ClientManager
+import com.github.rushyverse.api.player.ClientManagerImpl
+import com.github.rushyverse.api.translation.Translator
+import io.kotest.matchers.collections.shouldContainAll
+import io.kotest.matchers.shouldBe
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.time.Duration.Companion.minutes
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.test.runTest
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.inventory.InventoryType
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.InventoryHolder
+import org.bukkit.inventory.ItemStack
+import org.junit.jupiter.api.Nested
+
+class PersonalGUITest: AbstractKoinTest() {
+
+    private lateinit var guiManager: GUIManager
+    private lateinit var clientManager: ClientManager
+    private lateinit var translator: Translator
+    private lateinit var serverMock: ServerMock
+
+    @BeforeTest
+    override fun onBefore() {
+        super.onBefore()
+        guiManager = GUIManager()
+        clientManager = ClientManagerImpl()
+
+
+        loadApiTestModule {
+            single { guiManager }
+            single { clientManager }
+        }
+
+        serverMock = MockBukkit.mock()
+    }
+
+    @AfterTest
+    override fun onAfter() {
+        super.onAfter()
+        MockBukkit.unmock()
+    }
+
+    @Nested
+    inner class Open {
+
+    }
+
+    @Nested
+    inner class Viewers {
+
+    }
+
+    @Nested
+    inner class Contains {
+
+    }
+
+    @Nested
+    inner class CloseForClient {
+
+    }
+
+    @Nested
+    inner class Close {
+
+        @Test
+        fun `should close all inventories and remove all viewers`() = runTest(timeout = 1.minutes) {
+            val type = InventoryType.HOPPER
+            val gui = object : PersonalGUI() {
+                override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
+                    return serverMock.createInventory(owner, type)
+                }
+
+                override suspend fun fill(client: Client, inventory: Inventory) {}
+
+                override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
+                    error("Should not be called")
+                }
+            }
+
+            val playerClients = List(5) { registerPlayer() }
+            playerClients.forEach { (player, client) ->
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
+                client.gui() shouldBe gui
+            }
+
+            gui.close()
+            playerClients.forEach { (player, client) ->
+                player.assertInventoryView(InventoryType.CRAFTING)
+                client.gui() shouldBe null
+            }
+        }
+
+        @Test
+        fun `should set isClosed to true`() {
+            val gui = createGUI()
+            gui.isClosed shouldBe false
+            gui.close()
+            gui.isClosed shouldBe true
+        }
+
+        @Test
+        fun `should unregister the GUI`() {
+            val gui = createGUI()
+            guiManager.guis shouldContainAll listOf(gui)
+            gui.close()
+            guiManager.guis shouldContainAll listOf()
+        }
+
+        private fun createGUI(): PersonalGUI {
+            return object : PersonalGUI() {
+                override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
+                    error("Should not be called")
+                }
+
+                override suspend fun fill(client: Client, inventory: Inventory) {
+                    error("Should not be called")
+                }
+
+                override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
+                    error("Should not be called")
+                }
+            }
+        }
+
+    }
+
+    private suspend fun registerPlayer(): Pair<PlayerMock, Client> {
+        val player = serverMock.addPlayer()
+        val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+        clientManager.put(player, client)
+        return player to client
+    }
+}

From c8d302ce9ee84a933de564a3e55b82c58c5937cc Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 16:15:28 +0100
Subject: [PATCH 13/50] fix(personal-gui): Create custom inventory for personal
 GUI

---
 .../github/rushyverse/api/gui/PersonalGUI.kt    | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 4e24275a..2beb9532 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -1,24 +1,16 @@
 package com.github.rushyverse.api.gui
 
-import com.github.rushyverse.api.extension.toTranslatedComponent
-import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.Client
-import com.github.rushyverse.api.translation.Translator
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import net.kyori.adventure.text.Component
 import org.bukkit.entity.HumanEntity
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.InventoryHolder
 
 /**
  * GUI where a new inventory is created for each viewer.
- * @property title Title that can be translated.
- * @property translator Translator to translate the title.
  */
-public abstract class PersonalGUI(public val title: String) : GUI() {
-
-    protected val translator: Translator by inject()
+public abstract class PersonalGUI : GUI() {
 
     private var inventories: MutableMap<Client, Inventory> = mutableMapOf()
 
@@ -44,8 +36,7 @@ public abstract class PersonalGUI(public val title: String) : GUI() {
      */
     private suspend fun createInventory(client: Client): Inventory {
         val player = client.requirePlayer()
-        val translatedTitle = title.toTranslatedComponent(translator, client.lang().locale)
-        return createInventory(player, translatedTitle).also {
+        return createInventory(player, client).also {
             fill(client, it)
         }
     }
@@ -54,10 +45,10 @@ public abstract class PersonalGUI(public val title: String) : GUI() {
      * Create the inventory for the client.
      * This function is called when the [owner] wants to open the inventory.
      * @param owner Player who wants to open the inventory.
-     * @param title Translated title of the inventory.
+     * @param client The client to create the inventory for.
      * @return The inventory for the client.
      */
-    protected abstract fun createInventory(owner: InventoryHolder, title: Component): Inventory
+    protected abstract fun createInventory(owner: InventoryHolder, client: Client): Inventory
 
     /**
      * Fill the inventory with items for the client.

From 2efa65cdc2a2dc36025f40b00cc15ae8704ce25e Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 18:38:10 +0100
Subject: [PATCH 14/50] fix: Click on item when inventory open

---
 .../com/github/rushyverse/api/APIPlugin.kt    |  2 +-
 .../com/github/rushyverse/api/gui/GUI.kt      | 15 ++++
 .../github/rushyverse/api/gui/GUIListener.kt  | 70 ++++++++++++++++++-
 .../github/rushyverse/api/gui/PersonalGUI.kt  | 12 ++++
 .../github/rushyverse/api/gui/SharedGUI.kt    | 18 +++--
 .../rushyverse/api/gui/GUIListenerTest.kt     | 15 ++--
 .../rushyverse/api/gui/PersonalGUITest.kt     |  4 +-
 7 files changed, 124 insertions(+), 12 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
index e1b0480e..7b0abcc6 100644
--- a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
@@ -15,7 +15,7 @@ import org.bukkit.plugin.java.JavaPlugin
 /**
  * Plugin to enable the API in server.
  */
-public class APIPlugin : JavaPlugin() {
+public open class APIPlugin : JavaPlugin() {
 
     public companion object {
         /**
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index fbfab1ea..d35563af 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -7,6 +7,7 @@ import mu.KotlinLogging
 import org.bukkit.Server
 import org.bukkit.entity.HumanEntity
 import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 
 private val logger = KotlinLogging.logger {}
@@ -81,6 +82,20 @@ public abstract class GUI : Closeable {
      */
     public abstract suspend fun close(client: Client, closeInventory: Boolean = true): Boolean
 
+    /**
+     * Check if the GUI contains the inventory.
+     * @param inventory Inventory to check.
+     * @return True if the GUI contains the inventory, false otherwise.
+     */
+    public abstract suspend fun hasInventory(inventory: Inventory): Boolean
+
+    /**
+     * Get the inventory of the GUI for the client.
+     * @param client Client to get the inventory for.
+     * @return The inventory of the GUI for the client.
+     */
+    public abstract suspend fun getInventory(client: Client): Inventory?
+
     /**
      * Close the inventory.
      * The inventory will be closed for all the viewers.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
index f5314c31..af3cebc9 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
@@ -4,22 +4,34 @@ import com.github.rushyverse.api.Plugin
 import com.github.rushyverse.api.extension.event.cancel
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.ClientManager
+import com.github.shynixn.mccoroutine.bukkit.callSuspendingEvent
+import kotlinx.coroutines.joinAll
 import org.bukkit.Material
+import org.bukkit.Server
+import org.bukkit.block.BlockFace
 import org.bukkit.entity.HumanEntity
+import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
+import org.bukkit.event.block.Action
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.event.player.PlayerInteractEvent
 import org.bukkit.event.player.PlayerQuitEvent
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+import org.bukkit.inventory.PlayerInventory
 
 /**
  * Listener for GUI events.
  * @property clients Manager of clients.
  */
-public class GUIListener(plugin: Plugin) : Listener {
+public class GUIListener(private val plugin: Plugin) : Listener {
 
     private val clients: ClientManager by inject(plugin.id)
 
+    private val server: Server by inject()
+
     /**
      * Called when a player clicks on an item in an inventory.
      * If the click is detected in a GUI, the event is cancelled and the GUI is notified.
@@ -32,15 +44,71 @@ public class GUIListener(plugin: Plugin) : Listener {
         val item = event.currentItem
         if (item == null || item.type == Material.AIR) return
 
+        val clickedInventory = event.clickedInventory ?: return
+
         val player = event.whoClicked
+        if (clickedInventory is PlayerInventory) {
+            handleClickOnPlayerInventory(player as Player, item, event)
+        } else {
+            handleClickOnGUI(player, clickedInventory, item, event)
+        }
+    }
+
+    /**
+     * Called when a player clicks on an item in an inventory.
+     * @param player Player who clicked.
+     * @param clickedInventory Inventory where the click was detected.
+     * @param item Item that was clicked.
+     * @param event Event of the click.
+     */
+    private suspend fun handleClickOnGUI(
+        player: HumanEntity,
+        clickedInventory: Inventory,
+        item: ItemStack,
+        event: InventoryClickEvent
+    ) {
         val client = clients.getClient(player)
         val gui = client.gui() ?: return
+        if (!gui.hasInventory(clickedInventory)) {
+            return
+        }
 
         // The item in a GUI is not supposed to be moved
         event.cancel()
         gui.onClick(client, item, event)
     }
 
+    /**
+     * Called when a player clicks on an item in his inventory.
+     * To trigger the action linked to the clicked item,
+     * we produce a PlayerInteractEvent to simulate a right click with the item.
+     * @param player Player who clicked.
+     * @param item Item that was clicked.
+     */
+    private suspend fun handleClickOnPlayerInventory(player: Player, item: ItemStack, event: InventoryClickEvent) {
+        event.cancel()
+
+        val rightClickWithItemEvent = createRightClickWithItemEvent(player, item)
+        server.pluginManager.callSuspendingEvent(rightClickWithItemEvent, plugin).joinAll()
+    }
+
+    /**
+     * Create a PlayerInteractEvent to simulate a right click with an item.
+     * @param player Player who clicked.
+     * @param item Item that was clicked.
+     * @return The new event.
+     */
+    private fun createRightClickWithItemEvent(
+        player: Player,
+        item: ItemStack
+    ) = PlayerInteractEvent(
+        player,
+        Action.RIGHT_CLICK_AIR,
+        item,
+        null,
+        BlockFace.NORTH // random value not null
+    )
+
     /**
      * Called when a player closes an inventory.
      * If the inventory is a GUI, the GUI is notified that it is closed for this player.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 2beb9532..01c43ad4 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -79,6 +79,18 @@ public abstract class PersonalGUI : GUI() {
         }
     }
 
+    override suspend fun hasInventory(inventory: Inventory): Boolean {
+        return mutex.withLock {
+            inventories.values.contains(inventory)
+        }
+    }
+
+    override suspend fun getInventory(client: Client): Inventory? {
+        return mutex.withLock {
+            inventories[client]
+        }
+    }
+
     override fun close() {
         super.close()
         inventories.values.forEach(Inventory::close)
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index fec7407b..e5b30630 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -43,11 +43,10 @@ public abstract class SharedGUI : GUI() {
 
     override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
         val player = client.requirePlayer()
-        if (closeInventory && player.openInventory.topInventory == inventory) {
+        return if (closeInventory && player.openInventory.topInventory == inventory) {
             player.closeInventory()
-            return true
-        }
-        return false
+            true
+        } else false
     }
 
     override suspend fun viewers(): List<HumanEntity> {
@@ -58,6 +57,17 @@ public abstract class SharedGUI : GUI() {
         return client.player?.let { it in viewers() } == true
     }
 
+    override suspend fun hasInventory(inventory: Inventory): Boolean {
+        return this.inventory == inventory
+    }
+
+    override suspend fun getInventory(client: Client): Inventory? {
+        val player = client.player
+        return if (player != null && player in viewers()) {
+            inventory
+        } else null
+    }
+
     override fun close() {
         super.close()
         inventory?.close()
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 29772d72..6cc9ff7f 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -27,6 +27,7 @@ import org.bukkit.entity.Player
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.event.player.PlayerQuitEvent
+import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
 
@@ -68,7 +69,7 @@ class GUIListenerTest : AbstractKoinTest() {
                 coEvery { contains(client) } returns true
             }
 
-            callEvent(true, player, ItemStack { type = Material.DIRT })
+            callEvent(true, player, ItemStack { type = Material.DIRT }, player.inventory)
             coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
         }
 
@@ -80,7 +81,7 @@ class GUIListenerTest : AbstractKoinTest() {
             }
 
             suspend fun callEvent(item: ItemStack?) {
-                val event = callEvent(false, player, item)
+                val event = callEvent(false, player, item, player.inventory)
                 coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
                 verify(exactly = 0) { event.cancel() }
             }
@@ -96,20 +97,22 @@ class GUIListenerTest : AbstractKoinTest() {
                 coEvery { contains(client) } returns false
             }
 
-            callEvent(false, player, ItemStack { type = Material.DIRT })
+            callEvent(false, player, ItemStack { type = Material.DIRT }, player.inventory)
             coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
         }
 
         @Test
         fun `should call GUI onClick if client has opened one`() = runTest {
             val (player, client) = registerPlayer()
+            val inventory = mockk<Inventory>()
             val gui = registerGUI {
                 coEvery { contains(client) } returns true
                 coEvery { onClick(client, any(), any()) } returns Unit
+                coEvery { hasInventory(inventory) } returns true
             }
 
             val item = ItemStack { type = Material.DIRT }
-            val event = callEvent(false, player, item)
+            val event = callEvent(false, player, item, inventory)
             coVerify(exactly = 1) { gui.onClick(client, item, event) }
             verify(exactly = 1) { event.cancel() }
         }
@@ -117,13 +120,15 @@ class GUIListenerTest : AbstractKoinTest() {
         private suspend fun callEvent(
             cancel: Boolean,
             player: Player,
-            item: ItemStack?
+            item: ItemStack?,
+            inventory: Inventory?
         ): InventoryClickEvent {
             val event = mockk<InventoryClickEvent> {
                 every { isCancelled } returns cancel
                 every { whoClicked } returns player
                 every { currentItem } returns item
                 every { cancel() } returns Unit
+                every { clickedInventory } returns inventory
             }
 
             listener.onInventoryClick(event)
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
index 6ad873d7..14558300 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
@@ -78,6 +78,7 @@ class PersonalGUITest: AbstractKoinTest() {
         @Test
         fun `should close all inventories and remove all viewers`() = runTest(timeout = 1.minutes) {
             val type = InventoryType.HOPPER
+            val initType = InventoryType.CRAFTING
             val gui = object : PersonalGUI() {
                 override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
                     return serverMock.createInventory(owner, type)
@@ -92,6 +93,7 @@ class PersonalGUITest: AbstractKoinTest() {
 
             val playerClients = List(5) { registerPlayer() }
             playerClients.forEach { (player, client) ->
+                player.assertInventoryView(initType)
                 gui.open(client) shouldBe true
                 player.assertInventoryView(type)
                 client.gui() shouldBe gui
@@ -99,7 +101,7 @@ class PersonalGUITest: AbstractKoinTest() {
 
             gui.close()
             playerClients.forEach { (player, client) ->
-                player.assertInventoryView(InventoryType.CRAFTING)
+                player.assertInventoryView(initType)
                 client.gui() shouldBe null
             }
         }

From 8cd1bab75e849b684e85aa47b5227b9fd93c9616 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 19:30:56 +0100
Subject: [PATCH 15/50] test: Fix test about call suspending event

---
 .../github/rushyverse/api/AbstractKoinTest.kt    | 16 ++++++++++++++--
 .../github/rushyverse/api/gui/GUIListenerTest.kt |  9 +++++++--
 .../github/rushyverse/api/gui/PersonalGUITest.kt |  5 +----
 3 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt b/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt
index 4a7ea6aa..df562752 100644
--- a/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt
@@ -5,15 +5,18 @@ import com.github.rushyverse.api.koin.loadModule
 import com.github.rushyverse.api.utils.randomString
 import io.mockk.every
 import io.mockk.mockk
-import org.koin.core.module.Module
-import org.koin.dsl.ModuleDeclaration
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
+import org.bukkit.Server
+import org.koin.core.module.Module
+import org.koin.dsl.ModuleDeclaration
 
 open class AbstractKoinTest {
 
     lateinit var plugin: Plugin
 
+    lateinit var server: Server
+
     private lateinit var pluginId: String
 
     @BeforeTest
@@ -22,13 +25,22 @@ open class AbstractKoinTest {
         CraftContext.startKoin(pluginId) { }
         CraftContext.startKoin(APIPlugin.ID_API) { }
 
+        server = mockk {
+            every { pluginManager } returns mockk()
+        }
+
         loadTestModule {
             plugin = mockk {
                 every { id } returns pluginId
                 every { name } returns randomString()
+                every { server } returns this@AbstractKoinTest.server
             }
             single { plugin }
         }
+
+        loadApiTestModule {
+            single { server }
+        }
     }
 
     @AfterTest
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 6cc9ff7f..3950cb2b 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -8,13 +8,13 @@ import com.github.rushyverse.api.extension.event.cancel
 import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
-import com.github.rushyverse.api.utils.randomString
+import com.github.shynixn.mccoroutine.bukkit.callSuspendingEvent
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
+import io.mockk.mockkStatic
 import io.mockk.verify
-import java.util.*
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
@@ -97,6 +97,11 @@ class GUIListenerTest : AbstractKoinTest() {
                 coEvery { contains(client) } returns false
             }
 
+            val pluginManager = server.pluginManager
+
+            mockkStatic("com.github.shynixn.mccoroutine.bukkit.MCCoroutineKt")
+            every { pluginManager.callSuspendingEvent(any(), plugin) } returns emptyList()
+
             callEvent(false, player, ItemStack { type = Material.DIRT }, player.inventory)
             coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
         }
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
index 14558300..5879a493 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
@@ -7,7 +7,6 @@ import com.github.rushyverse.api.AbstractKoinTest
 import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
-import com.github.rushyverse.api.translation.Translator
 import io.kotest.matchers.collections.shouldContainAll
 import io.kotest.matchers.shouldBe
 import kotlin.coroutines.EmptyCoroutineContext
@@ -24,11 +23,10 @@ import org.bukkit.inventory.InventoryHolder
 import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
 
-class PersonalGUITest: AbstractKoinTest() {
+class PersonalGUITest : AbstractKoinTest() {
 
     private lateinit var guiManager: GUIManager
     private lateinit var clientManager: ClientManager
-    private lateinit var translator: Translator
     private lateinit var serverMock: ServerMock
 
     @BeforeTest
@@ -37,7 +35,6 @@ class PersonalGUITest: AbstractKoinTest() {
         guiManager = GUIManager()
         clientManager = ClientManagerImpl()
 
-
         loadApiTestModule {
             single { guiManager }
             single { clientManager }

From e3890f1d0f86a79bc8ff34d2a48c436b23ec9a5c Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 22:30:55 +0100
Subject: [PATCH 16/50] test: Add test to trigger call event

---
 .../rushyverse/api/gui/GUIListenerTest.kt     | 47 +++++++++++++++++--
 1 file changed, 44 insertions(+), 3 deletions(-)

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 3950cb2b..54900bb5 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -9,23 +9,31 @@ import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
 import com.github.shynixn.mccoroutine.bukkit.callSuspendingEvent
+import io.kotest.matchers.shouldBe
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.unmockkAll
 import io.mockk.verify
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
+import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.test.runTest
 import net.kyori.adventure.text.Component
 import org.bukkit.Material
 import org.bukkit.entity.Player
+import org.bukkit.event.block.Action
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.event.player.PlayerInteractEvent
 import org.bukkit.event.player.PlayerQuitEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
@@ -51,12 +59,14 @@ class GUIListenerTest : AbstractKoinTest() {
         }
 
         serverMock = MockBukkit.mock()
+        mockkStatic("com.github.shynixn.mccoroutine.bukkit.MCCoroutineKt")
     }
 
     @AfterTest
     override fun onAfter() {
         super.onAfter()
         MockBukkit.unmock()
+        unmockkAll()
     }
 
     @Nested
@@ -93,17 +103,48 @@ class GUIListenerTest : AbstractKoinTest() {
         @Test
         fun `should do nothing if client doesn't have a GUI opened`() = runTest {
             val (player, client) = registerPlayer()
+
             val gui = registerGUI {
                 coEvery { contains(client) } returns false
+                coEvery { hasInventory(any()) } returns false
             }
 
             val pluginManager = server.pluginManager
 
-            mockkStatic("com.github.shynixn.mccoroutine.bukkit.MCCoroutineKt")
-            every { pluginManager.callSuspendingEvent(any(), plugin) } returns emptyList()
+            val item = ItemStack { type = Material.DIRT }
+            callEvent(false, player, item, mockk())
+
+            coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+            verify(exactly = 0) { pluginManager.callSuspendingEvent(any(), plugin) }
+        }
+
+        @Test
+        fun `should trigger right click event if player select his own inventory`() = runTest {
+            val (player, client) = registerPlayer()
+            val gui = registerGUI {
+                coEvery { contains(client) } returns false
+            }
+
+            val pluginManager = server.pluginManager
+
+            val slot = slot<PlayerInteractEvent>()
+            val jobs = List(5) {
+                async { delay(1.seconds) }
+            }
+            every { pluginManager.callSuspendingEvent(capture(slot), plugin) } returns jobs
+
+            val item = ItemStack { type = Material.DIRT }
 
-            callEvent(false, player, ItemStack { type = Material.DIRT }, player.inventory)
+            callEvent(false, player, item, player.inventory)
             coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+            verify(exactly = 1) { pluginManager.callSuspendingEvent(any(), plugin) }
+            jobs.forEach { it.isCompleted shouldBe true }
+
+            val event = slot.captured
+            event.player shouldBe player
+            event.action shouldBe Action.RIGHT_CLICK_AIR
+            event.item shouldBe item
+            event.clickedBlock shouldBe null
         }
 
         @Test

From a93e84e7843a5a3b0e626fd55d9e3affb7af1f36 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 23:44:23 +0100
Subject: [PATCH 17/50] test: Implement tests for Personal GUI

---
 .../com/github/rushyverse/api/gui/GUI.kt      |   6 +-
 .../github/rushyverse/api/gui/PersonalGUI.kt  |  26 ++--
 .../rushyverse/api/gui/PersonalGUITest.kt     | 131 +++++++++++++-----
 3 files changed, 112 insertions(+), 51 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index d35563af..7b400183 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -19,7 +19,7 @@ private val logger = KotlinLogging.logger {}
  * @property manager Manager to register or unregister the GUI.
  * @property isClosed If true, the GUI is closed; otherwise it is open.
  */
-public abstract class GUI : Closeable {
+public abstract class GUI {
 
     protected val server: Server by inject()
 
@@ -101,7 +101,7 @@ public abstract class GUI : Closeable {
      * The inventory will be closed for all the viewers.
      * The GUI will be removed from the listener and the [onClick] function will not be called anymore.
      */
-    public override fun close() {
+    public open suspend fun close() {
         isClosed = true
         unregister()
     }
@@ -110,7 +110,7 @@ public abstract class GUI : Closeable {
      * Verify that the GUI is open.
      * If the GUI is closed, throw an exception.
      */
-    protected fun requireOpen() {
+    private fun requireOpen() {
         require(!isClosed) { "Cannot use a closed GUI" }
     }
 
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
index 01c43ad4..ad8d5be7 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
@@ -58,15 +58,6 @@ public abstract class PersonalGUI : GUI() {
      */
     protected abstract suspend fun fill(client: Client, inventory: Inventory)
 
-    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
-        return mutex.withLock { inventories.remove(client) }?.run {
-            if (closeInventory) {
-                close()
-            }
-            true
-        } == true
-    }
-
     override suspend fun viewers(): List<HumanEntity> {
         return mutex.withLock {
             inventories.values.flatMap(Inventory::getViewers)
@@ -91,9 +82,20 @@ public abstract class PersonalGUI : GUI() {
         }
     }
 
-    override fun close() {
+    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+        return mutex.withLock { inventories.remove(client) }?.run {
+            if (closeInventory) {
+                client.player?.closeInventory()
+            }
+            true
+        } == true
+    }
+
+    override suspend fun close() {
         super.close()
-        inventories.values.forEach(Inventory::close)
-        inventories.clear()
+        mutex.withLock {
+            inventories.values.forEach(Inventory::close)
+            inventories.clear()
+        }
     }
 }
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
index 5879a493..fbf220b2 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
@@ -8,6 +8,7 @@ import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
 import io.kotest.matchers.collections.shouldContainAll
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.shouldBe
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.AfterTest
@@ -57,16 +58,87 @@ class PersonalGUITest : AbstractKoinTest() {
     @Nested
     inner class Viewers {
 
+        @Test
+        fun `should return empty list if no client is viewing the GUI`() = runTest {
+            val gui = TestGUI(serverMock)
+            gui.viewers() shouldBe emptyList()
+        }
+
+        @Test
+        fun `should return the list of clients viewing the GUI`() = runTest {
+            val gui = TestGUI(serverMock)
+            val playerClients = List(5) { registerPlayer() }
+
+            playerClients.forEach { (_, client) ->
+                gui.open(client) shouldBe true
+            }
+
+            gui.viewers() shouldContainExactlyInAnyOrder playerClients.map { it.first }
+        }
+
     }
 
     @Nested
     inner class Contains {
 
+        @Test
+        fun `should return false if the client is not viewing the GUI`() = runTest {
+            val gui = TestGUI(serverMock)
+            val (_, client) = registerPlayer()
+            gui.contains(client) shouldBe false
+        }
+
+        @Test
+        fun `should return true if the client is viewing the GUI`() = runTest {
+            val gui = TestGUI(serverMock)
+            val (_, client) = registerPlayer()
+            gui.open(client) shouldBe true
+            gui.contains(client) shouldBe true
+        }
+
     }
 
     @Nested
     inner class CloseForClient {
 
+        @Test
+        fun `should return false if the client is not viewing the GUI`() = runTest(timeout = 1.minutes) {
+            val gui = TestGUI(serverMock)
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+
+            player.assertInventoryView(initialInventoryViewType)
+            gui.close(client, true) shouldBe false
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should close the inventory if the client is viewing the GUI`() = runTest(timeout = 1.minutes) {
+            val gui = TestGUI(serverMock)
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+
+            gui.open(client) shouldBe true
+            player.assertInventoryView(gui.type)
+            gui.close(client, true) shouldBe true
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should remove client inventory without closing it if closeInventory is false`() =
+            runTest(timeout = 1.minutes) {
+                val gui = TestGUI(serverMock)
+                val (player, client) = registerPlayer()
+
+                gui.open(client) shouldBe true
+                player.assertInventoryView(gui.type)
+                gui.close(client, false) shouldBe true
+                player.assertInventoryView(gui.type)
+                gui.contains(client) shouldBe false
+            }
+
     }
 
     @Nested
@@ -74,67 +146,41 @@ class PersonalGUITest : AbstractKoinTest() {
 
         @Test
         fun `should close all inventories and remove all viewers`() = runTest(timeout = 1.minutes) {
-            val type = InventoryType.HOPPER
-            val initType = InventoryType.CRAFTING
-            val gui = object : PersonalGUI() {
-                override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
-                    return serverMock.createInventory(owner, type)
-                }
-
-                override suspend fun fill(client: Client, inventory: Inventory) {}
-
-                override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
-                    error("Should not be called")
-                }
-            }
+            val gui = TestGUI(serverMock, InventoryType.BREWING)
 
             val playerClients = List(5) { registerPlayer() }
+            val initialInventoryViewType = playerClients.first().first.openInventory.type
+
             playerClients.forEach { (player, client) ->
-                player.assertInventoryView(initType)
+                player.assertInventoryView(initialInventoryViewType)
                 gui.open(client) shouldBe true
-                player.assertInventoryView(type)
+                player.assertInventoryView(gui.type)
                 client.gui() shouldBe gui
             }
 
             gui.close()
             playerClients.forEach { (player, client) ->
-                player.assertInventoryView(initType)
+                player.assertInventoryView(initialInventoryViewType)
                 client.gui() shouldBe null
             }
         }
 
         @Test
-        fun `should set isClosed to true`() {
-            val gui = createGUI()
+        fun `should set isClosed to true`() = runTest {
+            val gui = TestGUI(serverMock)
             gui.isClosed shouldBe false
             gui.close()
             gui.isClosed shouldBe true
         }
 
         @Test
-        fun `should unregister the GUI`() {
-            val gui = createGUI()
+        fun `should unregister the GUI`() = runTest {
+            val gui = TestGUI(serverMock)
             guiManager.guis shouldContainAll listOf(gui)
             gui.close()
             guiManager.guis shouldContainAll listOf()
         }
 
-        private fun createGUI(): PersonalGUI {
-            return object : PersonalGUI() {
-                override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
-                    error("Should not be called")
-                }
-
-                override suspend fun fill(client: Client, inventory: Inventory) {
-                    error("Should not be called")
-                }
-
-                override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
-                    error("Should not be called")
-                }
-            }
-        }
-
     }
 
     private suspend fun registerPlayer(): Pair<PlayerMock, Client> {
@@ -144,3 +190,16 @@ class PersonalGUITest : AbstractKoinTest() {
         return player to client
     }
 }
+
+private class TestGUI(val serverMock: ServerMock, val type: InventoryType = InventoryType.HOPPER) : PersonalGUI() {
+    override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
+        return serverMock.createInventory(owner, type)
+    }
+
+    override suspend fun fill(client: Client, inventory: Inventory) {
+    }
+
+    override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
+        error("Should not be called")
+    }
+}

From 7301933d6046ccca95ab448f56b2a5864aade131 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 23:44:48 +0100
Subject: [PATCH 18/50] fix: Use mutex to avoid async issue

---
 .../github/rushyverse/api/gui/SharedGUI.kt    | 37 +++++++++++--------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index e5b30630..82c4c166 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -1,6 +1,8 @@
 package com.github.rushyverse.api.gui
 
 import com.github.rushyverse.api.player.Client
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.bukkit.entity.HumanEntity
 import org.bukkit.inventory.Inventory
 
@@ -15,6 +17,8 @@ public abstract class SharedGUI : GUI() {
 
     private var inventory: Inventory? = null
 
+    private val mutex = Mutex()
+
     override suspend fun openGUI(client: Client): Boolean {
         val player = client.requirePlayer()
         val inventory = getOrCreateInventory()
@@ -28,9 +32,11 @@ public abstract class SharedGUI : GUI() {
      * @return The inventory of the GUI.
      */
     private suspend fun getOrCreateInventory(): Inventory {
-        return inventory ?: createInventory().also {
-            inventory = it
-            fill(it)
+        return mutex.withLock {
+            inventory ?: createInventory().also {
+                inventory = it
+                fill(it)
+            }
         }
     }
 
@@ -42,15 +48,14 @@ public abstract class SharedGUI : GUI() {
     protected abstract fun createInventory(): Inventory
 
     override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
-        val player = client.requirePlayer()
-        return if (closeInventory && player.openInventory.topInventory == inventory) {
-            player.closeInventory()
+        return if (closeInventory && contains(client)) {
+            client.player?.closeInventory()
             true
         } else false
     }
 
     override suspend fun viewers(): List<HumanEntity> {
-        return inventory?.viewers ?: emptyList()
+        return mutex.withLock { inventory?.viewers } ?: emptyList()
     }
 
     override suspend fun contains(client: Client): Boolean {
@@ -58,20 +63,22 @@ public abstract class SharedGUI : GUI() {
     }
 
     override suspend fun hasInventory(inventory: Inventory): Boolean {
-        return this.inventory == inventory
+        return mutex.withLock { this.inventory } == inventory
     }
 
     override suspend fun getInventory(client: Client): Inventory? {
-        val player = client.player
-        return if (player != null && player in viewers()) {
-            inventory
-        } else null
+        return if (contains(client)) mutex.withLock { inventory } else null
     }
 
-    override fun close() {
+    override suspend fun close() {
         super.close()
-        inventory?.close()
-        inventory = null
+        mutex.withLock {
+            val inventory = inventory
+            if(inventory != null) {
+                inventory.close()
+                this.inventory = null
+            }
+        }
     }
 
     /**

From 023777006301409193fda1750b7ea67f2e30299e Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Fri, 15 Dec 2023 23:53:46 +0100
Subject: [PATCH 19/50] chore: Remove import

---
 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 7b400183..7f36d1ad 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -2,7 +2,6 @@ package com.github.rushyverse.api.gui
 
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.Client
-import java.io.Closeable
 import mu.KotlinLogging
 import org.bukkit.Server
 import org.bukkit.entity.HumanEntity

From a47a1dc76942a119b92f9ed4437e6aae94d0ccdb Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Sat, 16 Dec 2023 00:58:33 +0100
Subject: [PATCH 20/50] test: Open GUI for Personal GUI

---
 .../com/github/rushyverse/api/gui/GUI.kt      |  16 ++-
 .../rushyverse/api/gui/PersonalGUITest.kt     | 104 ++++++++++++++++++
 2 files changed, 117 insertions(+), 3 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 7f36d1ad..7ea5026c 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -11,6 +11,16 @@ import org.bukkit.inventory.ItemStack
 
 private val logger = KotlinLogging.logger {}
 
+/**
+ * Exception concerning the GUI.
+ */
+public open class GUIException(message: String) : RuntimeException(message)
+
+/**
+ * Exception thrown when the GUI is closed.
+ */
+public class GUIClosedException(message: String) : GUIException(message)
+
 /**
  * GUI that can be shared by multiple players.
  * Only one inventory is created for all the viewers.
@@ -42,12 +52,12 @@ public abstract class GUI {
         requireOpen()
 
         val gui = client.gui()
-        if (gui == this) return false
+        if (gui === this) return false
         // If the client has another GUI opened, close it.
         gui?.close(client, true)
 
         val player = client.player
-        if (player == null) {
+        if (player === null) {
             logger.warn { "Cannot open inventory for player ${client.playerUUID}: player is null" }
             return false
         }
@@ -110,7 +120,7 @@ public abstract class GUI {
      * If the GUI is closed, throw an exception.
      */
     private fun requireOpen() {
-        require(!isClosed) { "Cannot use a closed GUI" }
+        if (isClosed) throw GUIClosedException("Cannot use a closed GUI")
     }
 
     /**
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
index fbf220b2..2fcea76c 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
@@ -4,12 +4,15 @@ import be.seeseemelk.mockbukkit.MockBukkit
 import be.seeseemelk.mockbukkit.ServerMock
 import be.seeseemelk.mockbukkit.entity.PlayerMock
 import com.github.rushyverse.api.AbstractKoinTest
+import com.github.rushyverse.api.extension.ItemStack
 import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.collections.shouldContainAll
 import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
@@ -17,6 +20,7 @@ import kotlin.test.Test
 import kotlin.time.Duration.Companion.minutes
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.test.runTest
+import org.bukkit.Material
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.Inventory
@@ -53,6 +57,90 @@ class PersonalGUITest : AbstractKoinTest() {
     @Nested
     inner class Open {
 
+        @Test
+        fun `should throw exception if GUI is closed`() = runTest {
+            val gui = TestGUI(serverMock)
+            gui.close()
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+            shouldThrow<GUIClosedException> { gui.open(client) }
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should do nothing if the client has the same GUI opened`() = runTest {
+            val gui = TestGUI(serverMock)
+            val (player, client) = registerPlayer()
+
+            gui.open(client) shouldBe true
+            player.assertInventoryView(gui.type)
+
+            gui.open(client) shouldBe false
+            player.assertInventoryView(gui.type)
+        }
+
+        @Test
+        fun `should close the previous GUI if the client has one opened`() = runTest {
+            val gui = TestGUI(serverMock, InventoryType.ENDER_CHEST)
+            val (player, client) = registerPlayer()
+
+            gui.open(client) shouldBe true
+            player.assertInventoryView(gui.type)
+
+            val gui2 = TestGUI(serverMock, InventoryType.CHEST)
+            gui2.open(client) shouldBe true
+            player.assertInventoryView(gui2.type)
+            gui.contains(client) shouldBe false
+            gui2.contains(client) shouldBe true
+        }
+
+        @Test
+        fun `should do nothing if the player is dead`() = runTest {
+            val gui = TestGUI(serverMock)
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+
+            player.damage(Double.MAX_VALUE)
+            gui.open(client) shouldBe false
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should create a new inventory for the client`() = runTest {
+            val gui = TestGUI(serverMock)
+            val (player, client) = registerPlayer()
+            val (player2, client2) = registerPlayer()
+
+            gui.open(client) shouldBe true
+            gui.open(client2) shouldBe true
+
+            player.assertInventoryView(gui.type)
+            player2.assertInventoryView(gui.type)
+
+            player.openInventory.topInventory shouldNotBe player2.openInventory.topInventory
+        }
+
+        @Test
+        fun `should fill the inventory`() = runTest {
+            val gui = TestFilledGUI(serverMock)
+            val (player, client) = registerPlayer()
+
+            gui.open(client) shouldBe true
+            player.assertInventoryView(InventoryType.CHEST)
+
+            val inventory = player.openInventory.topInventory
+            val content = inventory.contents
+            println(content.contentToString())
+            content[0]!!.type shouldBe Material.DIAMOND_ORE
+            content[1]!!.type shouldBe Material.STICK
+
+            for (i in 2 until content.size) {
+                content[i] shouldBe null
+            }
+        }
+
     }
 
     @Nested
@@ -197,6 +285,22 @@ private class TestGUI(val serverMock: ServerMock, val type: InventoryType = Inve
     }
 
     override suspend fun fill(client: Client, inventory: Inventory) {
+        // Do nothing
+    }
+
+    override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
+        error("Should not be called")
+    }
+}
+
+private class TestFilledGUI(val serverMock: ServerMock) : PersonalGUI() {
+    override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
+        return serverMock.createInventory(owner, InventoryType.CHEST)
+    }
+
+    override suspend fun fill(client: Client, inventory: Inventory) {
+        inventory.setItem(0, ItemStack { type = Material.DIAMOND_ORE })
+        inventory.setItem(1, ItemStack { type = Material.STICK })
     }
 
     override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {

From 5368455bc1db0990a9aaf6ef5613ee74940d6a61 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Sat, 16 Dec 2023 07:39:28 +0100
Subject: [PATCH 21/50] feat: Dedicate GUI for player or language

---
 .../github/rushyverse/api/gui/ClientGUI.kt    |  52 ++++++++
 .../github/rushyverse/api/gui/DedicatedGUI.kt | 112 ++++++++++++++++++
 .../com/github/rushyverse/api/gui/GUI.kt      |   7 --
 .../github/rushyverse/api/gui/PersonalGUI.kt  | 101 ----------------
 .../github/rushyverse/api/gui/SharedGUI.kt    |   6 +-
 .../rushyverse/api/gui/TranslateSharedGUI.kt  |  33 ++++++
 .../{PersonalGUITest.kt => ClientGUITest.kt}  |   6 +-
 7 files changed, 201 insertions(+), 116 deletions(-)
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/ClientGUI.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt
 delete mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/TranslateSharedGUI.kt
 rename src/test/kotlin/com/github/rushyverse/api/gui/{PersonalGUITest.kt => ClientGUITest.kt} (98%)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/ClientGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/ClientGUI.kt
new file mode 100644
index 00000000..ddf62c8f
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/ClientGUI.kt
@@ -0,0 +1,52 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.player.Client
+import kotlinx.coroutines.sync.withLock
+import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.InventoryHolder
+
+/**
+ * GUI where a new inventory is created for each player.
+ * An inventory is created when the player opens the GUI and he is not sharing the GUI with another player.
+ */
+public abstract class ClientGUI : DedicatedGUI<Client>() {
+
+    override suspend fun getKey(client: Client): Client {
+        return client
+    }
+
+    /**
+     * Create the inventory for the client.
+     * Will translate the title and fill the inventory.
+     * @param key The client to create the inventory for.
+     * @return The inventory for the client.
+     */
+    override suspend fun createInventory(key: Client): Inventory {
+        val player = key.requirePlayer()
+        return createInventory(player, key)
+    }
+
+    /**
+     * Create the inventory for the client.
+     * This function is called when the [owner] wants to open the inventory.
+     * @param owner Player who wants to open the inventory.
+     * @param client The client to create the inventory for.
+     * @return The inventory for the client.
+     */
+    protected abstract fun createInventory(owner: InventoryHolder, client: Client): Inventory
+
+    override fun unsafeContains(client: Client): Boolean {
+        // Little optimization to avoid searching in the map from values.
+        return inventories.containsKey(client)
+    }
+
+    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+        return mutex.withLock { inventories.remove(client) }?.run {
+            if (closeInventory) {
+                client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
+            }
+            true
+        } == true
+    }
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt
new file mode 100644
index 00000000..164341ba
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt
@@ -0,0 +1,112 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.player.Client
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.bukkit.entity.HumanEntity
+import org.bukkit.inventory.Inventory
+
+/**
+ * GUI where a new inventory is created for each key used.
+ * @param T Type of the key.
+ * @property inventories Map of inventories for each key.
+ * @property mutex Mutex to process thread-safe operations.
+ */
+public abstract class DedicatedGUI<T> : GUI() {
+
+    protected var inventories: MutableMap<T, Inventory> = mutableMapOf()
+
+    protected val mutex: Mutex = Mutex()
+
+    override suspend fun openGUI(client: Client): Boolean {
+        val key = getKey(client)
+        val inventory = getOrCreateInventory(key)
+
+        val player = client.requirePlayer()
+        player.openInventory(inventory)
+
+        return true
+    }
+
+    /**
+     * Get the inventory for the key.
+     * If the inventory does not exist, create it.
+     * @param key Key to get the inventory for.
+     * @return The inventory for the key.
+     */
+    private suspend fun getOrCreateInventory(key: T): Inventory {
+        return mutex.withLock {
+            inventories[key] ?: createInventory(key).also {
+                inventories[key] = it
+                fill(key, it)
+            }
+        }
+    }
+
+    /**
+     * Get the key linked to the client to interact with the GUI.
+     * @param client Client to get the key for.
+     * @return The key.
+     */
+    protected abstract suspend fun getKey(client: Client): T
+
+    /**
+     * Create the inventory for the key.
+     * @param key Key to create the inventory for.
+     * @return New created inventory.
+     */
+    protected abstract suspend fun createInventory(key: T): Inventory
+
+    /**
+     * Fill the inventory for the key.
+     * @param key Key to fill the inventory for.
+     * @param inventory Inventory to fill.
+     */
+    protected abstract suspend fun fill(key: T, inventory: Inventory)
+
+    override suspend fun hasInventory(inventory: Inventory): Boolean {
+        return mutex.withLock {
+            inventories.values.contains(inventory)
+        }
+    }
+
+    override suspend fun viewers(): List<HumanEntity> {
+        return mutex.withLock {
+            unsafeViewers()
+        }
+    }
+
+    /**
+     * Get the viewers of the inventory.
+     * This function is not thread-safe.
+     * @return The viewers of the inventory.
+     */
+    protected open fun unsafeViewers(): List<HumanEntity> {
+        return inventories.values.flatMap(Inventory::getViewers)
+    }
+
+    override suspend fun contains(client: Client): Boolean {
+        return mutex.withLock {
+            unsafeContains(client)
+        }
+    }
+
+    /**
+     * Check if the GUI contains the client.
+     * This function is not thread-safe.
+     * @param client Client to check.
+     * @return True if the GUI contains the client, false otherwise.
+     */
+    protected open fun unsafeContains(client: Client): Boolean {
+        val player = client.player ?: return false
+        return inventories.values.any { it.viewers.contains(player) }
+    }
+
+    override suspend fun close() {
+        super.close()
+        mutex.withLock {
+            inventories.values.forEach(Inventory::close)
+            inventories.clear()
+        }
+    }
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 7ea5026c..ced3136c 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -98,13 +98,6 @@ public abstract class GUI {
      */
     public abstract suspend fun hasInventory(inventory: Inventory): Boolean
 
-    /**
-     * Get the inventory of the GUI for the client.
-     * @param client Client to get the inventory for.
-     * @return The inventory of the GUI for the client.
-     */
-    public abstract suspend fun getInventory(client: Client): Inventory?
-
     /**
      * Close the inventory.
      * The inventory will be closed for all the viewers.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
deleted file mode 100644
index ad8d5be7..00000000
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PersonalGUI.kt
+++ /dev/null
@@ -1,101 +0,0 @@
-package com.github.rushyverse.api.gui
-
-import com.github.rushyverse.api.player.Client
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import org.bukkit.entity.HumanEntity
-import org.bukkit.inventory.Inventory
-import org.bukkit.inventory.InventoryHolder
-
-/**
- * GUI where a new inventory is created for each viewer.
- */
-public abstract class PersonalGUI : GUI() {
-
-    private var inventories: MutableMap<Client, Inventory> = mutableMapOf()
-
-    private val mutex = Mutex()
-
-    override suspend fun openGUI(client: Client): Boolean {
-        val inventory = createInventory(client)
-
-        mutex.withLock { inventories[client] }?.close()
-
-        val player = client.requirePlayer()
-        player.openInventory(inventory)
-
-        mutex.withLock { inventories[client] = inventory }
-        return true
-    }
-
-    /**
-     * Create the inventory for the client.
-     * Will translate the title and fill the inventory.
-     * @param client The client to create the inventory for.
-     * @return The inventory for the client.
-     */
-    private suspend fun createInventory(client: Client): Inventory {
-        val player = client.requirePlayer()
-        return createInventory(player, client).also {
-            fill(client, it)
-        }
-    }
-
-    /**
-     * Create the inventory for the client.
-     * This function is called when the [owner] wants to open the inventory.
-     * @param owner Player who wants to open the inventory.
-     * @param client The client to create the inventory for.
-     * @return The inventory for the client.
-     */
-    protected abstract fun createInventory(owner: InventoryHolder, client: Client): Inventory
-
-    /**
-     * Fill the inventory with items for the client.
-     * This function is called when the inventory is created.
-     * @param client The client to fill the inventory for.
-     * @param inventory The inventory to fill.
-     */
-    protected abstract suspend fun fill(client: Client, inventory: Inventory)
-
-    override suspend fun viewers(): List<HumanEntity> {
-        return mutex.withLock {
-            inventories.values.flatMap(Inventory::getViewers)
-        }
-    }
-
-    override suspend fun contains(client: Client): Boolean {
-        return mutex.withLock {
-            inventories.containsKey(client)
-        }
-    }
-
-    override suspend fun hasInventory(inventory: Inventory): Boolean {
-        return mutex.withLock {
-            inventories.values.contains(inventory)
-        }
-    }
-
-    override suspend fun getInventory(client: Client): Inventory? {
-        return mutex.withLock {
-            inventories[client]
-        }
-    }
-
-    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
-        return mutex.withLock { inventories.remove(client) }?.run {
-            if (closeInventory) {
-                client.player?.closeInventory()
-            }
-            true
-        } == true
-    }
-
-    override suspend fun close() {
-        super.close()
-        mutex.withLock {
-            inventories.values.forEach(Inventory::close)
-            inventories.clear()
-        }
-    }
-}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
index 82c4c166..ab5ba5d7 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
@@ -66,15 +66,11 @@ public abstract class SharedGUI : GUI() {
         return mutex.withLock { this.inventory } == inventory
     }
 
-    override suspend fun getInventory(client: Client): Inventory? {
-        return if (contains(client)) mutex.withLock { inventory } else null
-    }
-
     override suspend fun close() {
         super.close()
         mutex.withLock {
             val inventory = inventory
-            if(inventory != null) {
+            if (inventory != null) {
                 inventory.close()
                 this.inventory = null
             }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/TranslateSharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/TranslateSharedGUI.kt
new file mode 100644
index 00000000..77386b99
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/TranslateSharedGUI.kt
@@ -0,0 +1,33 @@
+package com.github.rushyverse.api.gui
+
+import com.github.rushyverse.api.player.Client
+import java.util.*
+import kotlinx.coroutines.sync.withLock
+import org.bukkit.event.inventory.InventoryCloseEvent
+
+/**
+ * GUI where a new inventory is created for each language.
+ * This is useful to share the GUI between multiple players with the same language.
+ *
+ * For example, if two players have the same language, they will share the same inventory.
+ * If one of them changes their language, he will have another inventory dedicated to his new language.
+ */
+public abstract class TranslateSharedGUI : DedicatedGUI<Locale>() {
+
+    override suspend fun getKey(client: Client): Locale {
+        return client.lang().locale
+    }
+
+    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+        if (!closeInventory) {
+            return false
+        }
+
+        return mutex.withLock {
+            if (unsafeContains(client)) {
+                client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
+                true
+            } else false
+        }
+    }
+}
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/ClientGUITest.kt
similarity index 98%
rename from src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
rename to src/test/kotlin/com/github/rushyverse/api/gui/ClientGUITest.kt
index 2fcea76c..c6213a02 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PersonalGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/ClientGUITest.kt
@@ -28,7 +28,7 @@ import org.bukkit.inventory.InventoryHolder
 import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
 
-class PersonalGUITest : AbstractKoinTest() {
+class ClientGUITest : AbstractKoinTest() {
 
     private lateinit var guiManager: GUIManager
     private lateinit var clientManager: ClientManager
@@ -279,7 +279,7 @@ class PersonalGUITest : AbstractKoinTest() {
     }
 }
 
-private class TestGUI(val serverMock: ServerMock, val type: InventoryType = InventoryType.HOPPER) : PersonalGUI() {
+private class TestGUI(val serverMock: ServerMock, val type: InventoryType = InventoryType.HOPPER) : ClientGUI() {
     override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
         return serverMock.createInventory(owner, type)
     }
@@ -293,7 +293,7 @@ private class TestGUI(val serverMock: ServerMock, val type: InventoryType = Inve
     }
 }
 
-private class TestFilledGUI(val serverMock: ServerMock) : PersonalGUI() {
+private class TestFilledGUI(val serverMock: ServerMock) : ClientGUI() {
     override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
         return serverMock.createInventory(owner, InventoryType.CHEST)
     }

From ef66b2ce09231419d5dece0acdc1e6247fdb8575 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Sat, 16 Dec 2023 08:26:32 +0100
Subject: [PATCH 22/50] chore: Rename classes

---
 .../api/gui/{TranslateSharedGUI.kt => LocaleGUI.kt}         | 4 ++--
 .../rushyverse/api/gui/{ClientGUI.kt => PlayerGUI.kt}       | 2 +-
 .../rushyverse/api/gui/{SharedGUI.kt => SingleGUI.kt}       | 2 +-
 .../api/gui/{ClientGUITest.kt => PlayerGUITest.kt}          | 6 +++---
 4 files changed, 7 insertions(+), 7 deletions(-)
 rename src/main/kotlin/com/github/rushyverse/api/gui/{TranslateSharedGUI.kt => LocaleGUI.kt} (88%)
 rename src/main/kotlin/com/github/rushyverse/api/gui/{ClientGUI.kt => PlayerGUI.kt} (96%)
 rename src/main/kotlin/com/github/rushyverse/api/gui/{SharedGUI.kt => SingleGUI.kt} (98%)
 rename src/test/kotlin/com/github/rushyverse/api/gui/{ClientGUITest.kt => PlayerGUITest.kt} (98%)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/TranslateSharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
similarity index 88%
rename from src/main/kotlin/com/github/rushyverse/api/gui/TranslateSharedGUI.kt
rename to src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
index 77386b99..9c004504 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/TranslateSharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
@@ -6,13 +6,13 @@ import kotlinx.coroutines.sync.withLock
 import org.bukkit.event.inventory.InventoryCloseEvent
 
 /**
- * GUI where a new inventory is created for each language.
+ * GUI where a new inventory is created for each [locale][Locale].
  * This is useful to share the GUI between multiple players with the same language.
  *
  * For example, if two players have the same language, they will share the same inventory.
  * If one of them changes their language, he will have another inventory dedicated to his new language.
  */
-public abstract class TranslateSharedGUI : DedicatedGUI<Locale>() {
+public abstract class LocaleGUI : DedicatedGUI<Locale>() {
 
     override suspend fun getKey(client: Client): Locale {
         return client.lang().locale
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/ClientGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
similarity index 96%
rename from src/main/kotlin/com/github/rushyverse/api/gui/ClientGUI.kt
rename to src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
index ddf62c8f..cd3524b9 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/ClientGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
@@ -10,7 +10,7 @@ import org.bukkit.inventory.InventoryHolder
  * GUI where a new inventory is created for each player.
  * An inventory is created when the player opens the GUI and he is not sharing the GUI with another player.
  */
-public abstract class ClientGUI : DedicatedGUI<Client>() {
+public abstract class PlayerGUI : DedicatedGUI<Client>() {
 
     override suspend fun getKey(client: Client): Client {
         return client
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
similarity index 98%
rename from src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
rename to src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
index ab5ba5d7..167c74d5 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SharedGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
@@ -13,7 +13,7 @@ import org.bukkit.inventory.Inventory
  * @property viewers List of viewers.
  * @property inventory Inventory shared by all the viewers.
  */
-public abstract class SharedGUI : GUI() {
+public abstract class SingleGUI : GUI() {
 
     private var inventory: Inventory? = null
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/ClientGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
similarity index 98%
rename from src/test/kotlin/com/github/rushyverse/api/gui/ClientGUITest.kt
rename to src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
index c6213a02..949d4d15 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/ClientGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
@@ -28,7 +28,7 @@ import org.bukkit.inventory.InventoryHolder
 import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
 
-class ClientGUITest : AbstractKoinTest() {
+class PlayerGUITest : AbstractKoinTest() {
 
     private lateinit var guiManager: GUIManager
     private lateinit var clientManager: ClientManager
@@ -279,7 +279,7 @@ class ClientGUITest : AbstractKoinTest() {
     }
 }
 
-private class TestGUI(val serverMock: ServerMock, val type: InventoryType = InventoryType.HOPPER) : ClientGUI() {
+private class TestGUI(val serverMock: ServerMock, val type: InventoryType = InventoryType.HOPPER) : PlayerGUI() {
     override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
         return serverMock.createInventory(owner, type)
     }
@@ -293,7 +293,7 @@ private class TestGUI(val serverMock: ServerMock, val type: InventoryType = Inve
     }
 }
 
-private class TestFilledGUI(val serverMock: ServerMock) : ClientGUI() {
+private class TestFilledGUI(val serverMock: ServerMock) : PlayerGUI() {
     override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
         return serverMock.createInventory(owner, InventoryType.CHEST)
     }

From 0bc8fd13416706de91502dbeaa84724ad510f038 Mon Sep 17 00:00:00 2001
From: Distractic <46402441+Distractic@users.noreply.github.com>
Date: Tue, 19 Dec 2023 10:20:27 +0100
Subject: [PATCH 23/50] feat: Loading GUI (#134)

---
 .../github/rushyverse/api/gui/DedicatedGUI.kt | 112 ------
 .../com/github/rushyverse/api/gui/GUI.kt      | 295 ++++++++++++--
 .../github/rushyverse/api/gui/GUIListener.kt  |  26 +-
 .../github/rushyverse/api/gui/GUIManager.kt   |  25 +-
 .../github/rushyverse/api/gui/LocaleGUI.kt    |  37 +-
 .../github/rushyverse/api/gui/PlayerGUI.kt    |  33 +-
 .../github/rushyverse/api/gui/SingleGUI.kt    |  91 ++---
 .../api/gui/load/InventoryLoadingAnimation.kt |  18 +
 .../load/ShiftInventoryLoadingAnimation.kt    |  48 +++
 .../github/rushyverse/api/player/Client.kt    |   2 +-
 .../github/rushyverse/api/AbstractKoinTest.kt |   2 +
 .../rushyverse/api/gui/AbstractGUITest.kt     | 373 ++++++++++++++++++
 .../rushyverse/api/gui/GUIListenerTest.kt     |  45 +--
 .../rushyverse/api/gui/GUIManagerTest.kt      |  34 +-
 .../rushyverse/api/gui/LocalePlayerGUITest.kt | 226 +++++++++++
 .../rushyverse/api/gui/PlayerGUITest.kt       | 333 +++++-----------
 .../rushyverse/api/gui/SingleGUITest.kt       | 195 +++++++++
 .../rushyverse/api/player/ClientTest.kt       |  16 +-
 18 files changed, 1371 insertions(+), 540 deletions(-)
 delete mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/load/InventoryLoadingAnimation.kt
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt
deleted file mode 100644
index 164341ba..00000000
--- a/src/main/kotlin/com/github/rushyverse/api/gui/DedicatedGUI.kt
+++ /dev/null
@@ -1,112 +0,0 @@
-package com.github.rushyverse.api.gui
-
-import com.github.rushyverse.api.player.Client
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import org.bukkit.entity.HumanEntity
-import org.bukkit.inventory.Inventory
-
-/**
- * GUI where a new inventory is created for each key used.
- * @param T Type of the key.
- * @property inventories Map of inventories for each key.
- * @property mutex Mutex to process thread-safe operations.
- */
-public abstract class DedicatedGUI<T> : GUI() {
-
-    protected var inventories: MutableMap<T, Inventory> = mutableMapOf()
-
-    protected val mutex: Mutex = Mutex()
-
-    override suspend fun openGUI(client: Client): Boolean {
-        val key = getKey(client)
-        val inventory = getOrCreateInventory(key)
-
-        val player = client.requirePlayer()
-        player.openInventory(inventory)
-
-        return true
-    }
-
-    /**
-     * Get the inventory for the key.
-     * If the inventory does not exist, create it.
-     * @param key Key to get the inventory for.
-     * @return The inventory for the key.
-     */
-    private suspend fun getOrCreateInventory(key: T): Inventory {
-        return mutex.withLock {
-            inventories[key] ?: createInventory(key).also {
-                inventories[key] = it
-                fill(key, it)
-            }
-        }
-    }
-
-    /**
-     * Get the key linked to the client to interact with the GUI.
-     * @param client Client to get the key for.
-     * @return The key.
-     */
-    protected abstract suspend fun getKey(client: Client): T
-
-    /**
-     * Create the inventory for the key.
-     * @param key Key to create the inventory for.
-     * @return New created inventory.
-     */
-    protected abstract suspend fun createInventory(key: T): Inventory
-
-    /**
-     * Fill the inventory for the key.
-     * @param key Key to fill the inventory for.
-     * @param inventory Inventory to fill.
-     */
-    protected abstract suspend fun fill(key: T, inventory: Inventory)
-
-    override suspend fun hasInventory(inventory: Inventory): Boolean {
-        return mutex.withLock {
-            inventories.values.contains(inventory)
-        }
-    }
-
-    override suspend fun viewers(): List<HumanEntity> {
-        return mutex.withLock {
-            unsafeViewers()
-        }
-    }
-
-    /**
-     * Get the viewers of the inventory.
-     * This function is not thread-safe.
-     * @return The viewers of the inventory.
-     */
-    protected open fun unsafeViewers(): List<HumanEntity> {
-        return inventories.values.flatMap(Inventory::getViewers)
-    }
-
-    override suspend fun contains(client: Client): Boolean {
-        return mutex.withLock {
-            unsafeContains(client)
-        }
-    }
-
-    /**
-     * Check if the GUI contains the client.
-     * This function is not thread-safe.
-     * @param client Client to check.
-     * @return True if the GUI contains the client, false otherwise.
-     */
-    protected open fun unsafeContains(client: Client): Boolean {
-        val player = client.player ?: return false
-        return inventories.values.any { it.viewers.contains(player) }
-    }
-
-    override suspend fun close() {
-        super.close()
-        mutex.withLock {
-            inventories.values.forEach(Inventory::close)
-            inventories.clear()
-        }
-    }
-}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index ced3136c..9f037538 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -1,26 +1,67 @@
 package com.github.rushyverse.api.gui
 
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.Client
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.cancellable
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import mu.KotlinLogging
+import org.bukkit.Material
 import org.bukkit.Server
 import org.bukkit.entity.HumanEntity
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 
+/**
+ * Pair of an index and an ItemStack.
+ */
+public typealias ItemStackIndex = Pair<Int, ItemStack?>
+
+/**
+ * Data class to store the inventory and the loading job.
+ * Can be used to cancel the loading job if the inventory is closed.
+ * @property inventory Inventory created.
+ * @property job Loading job to fill & animate the loading of the inventory.
+ * @property isLoading If true, the inventory is loading; otherwise it is filled or cancelled.
+ */
+public data class InventoryData(
+    val inventory: Inventory,
+    val job: Job,
+) {
+
+    val isLoading: Boolean get() = job.isActive
+
+}
+
 private val logger = KotlinLogging.logger {}
 
 /**
  * Exception concerning the GUI.
  */
-public open class GUIException(message: String) : RuntimeException(message)
+public open class GUIException(message: String) : CancellationException(message)
 
 /**
  * Exception thrown when the GUI is closed.
  */
 public class GUIClosedException(message: String) : GUIException(message)
 
+/**
+ * Exception thrown when the GUI is closed for a specific client.
+ * @property client Client for which the GUI is closed.
+ */
+public class GUIClosedForClientException(public val client: Client) :
+    GUIException("GUI closed for client ${client.playerUUID}")
+
 /**
  * GUI that can be shared by multiple players.
  * Only one inventory is created for all the viewers.
@@ -28,18 +69,35 @@ public class GUIClosedException(message: String) : GUIException(message)
  * @property manager Manager to register or unregister the GUI.
  * @property isClosed If true, the GUI is closed; otherwise it is open.
  */
-public abstract class GUI {
+public abstract class GUI<T>(
+    private val loadingAnimation: InventoryLoadingAnimation<T>? = null,
+    initialNumberInventories: Int = 16,
+) {
 
     protected val server: Server by inject()
 
-    private val manager: GUIManager by inject()
+    protected val manager: GUIManager by inject()
 
     public var isClosed: Boolean = false
         protected set
 
-    init {
-        register()
-    }
+    protected var inventories: MutableMap<T, InventoryData> = HashMap(initialNumberInventories)
+
+    protected val mutex: Mutex = Mutex()
+
+    /**
+     * Get the key linked to the client to interact with the GUI.
+     * @param client Client to get the key for.
+     * @return The key.
+     */
+    protected abstract suspend fun getKey(client: Client): T
+
+    /**
+     * Get the coroutine scope to fill the inventory and the loading animation.
+     * @param key Key to get the coroutine scope for.
+     * @return The coroutine scope.
+     */
+    protected abstract suspend fun fillScope(key: T): CoroutineScope
 
     /**
      * Open the GUI for the client only if the GUI is not closed.
@@ -51,11 +109,6 @@ public abstract class GUI {
     public suspend fun open(client: Client): Boolean {
         requireOpen()
 
-        val gui = client.gui()
-        if (gui === this) return false
-        // If the client has another GUI opened, close it.
-        gui?.close(client, true)
-
         val player = client.player
         if (player === null) {
             logger.warn { "Cannot open inventory for player ${client.playerUUID}: player is null" }
@@ -64,39 +117,174 @@ public abstract class GUI {
         // If the player is dead, do not open the GUI because the interface cannot be shown to the player.
         if (player.isDead) return false
 
-        return openGUI(client)
+        val gui = client.gui()
+        if (gui === this) return false
+
+        // Here we don't need
+        // to force to close the GUI because the GUI is closed when the player opens another inventory
+        // (if not cancelled).
+
+        val key = getKey(client)
+        val inventory = getOrCreateInventory(key)
+
+        // We open the inventory out of the mutex to avoid blocking operation from registered Listener.
+        if (player.openInventory(inventory) == null) {
+            // If the opening was cancelled (null returned),
+            // We need to unregister the client from the GUI
+            // and maybe close the inventory if it is individual.
+            close(client, false)
+            return false
+        }
+
+        return true
     }
 
     /**
-     * Open the GUI for the client.
-     * Called by [open] after all the checks.
-     * @param client Client to open the GUI for.
-     * @return True if the GUI was opened, false otherwise.
+     * Get the inventory for the key.
+     * If the inventory does not exist, create it.
+     * @param key Key to get the inventory for.
+     * @return The inventory for the key.
      */
-    protected abstract suspend fun openGUI(client: Client): Boolean
+    private suspend fun getOrCreateInventory(key: T): Inventory {
+        return mutex.withLock {
+            val loadedInventory = inventories[key]
+            if (loadedInventory != null) {
+                return@withLock loadedInventory.inventory
+            }
+
+            val inventory = createInventory(key)
+            // Start the fill asynchronously to avoid blocking the other inventory creation with the mutex.
+            val loadingJob = startLoadingInventory(key, inventory)
+            inventories[key] = InventoryData(inventory, loadingJob)
+
+            inventory
+        }
+    }
 
     /**
-     * Action to do when the client clicks on an item in the inventory.
-     * @param client Client who clicked.
-     * @param clickedItem Item clicked by the client.
-     * @param event Event of the click.
+     * Start the asynchronous loading animation and fill the inventory.
+     * @param key Key to create the inventory for.
+     * @param inventory Inventory to fill and animate.
+     * @return The job that can be cancelled to stop the loading animation.
+     */
+    private suspend fun startLoadingInventory(key: T, inventory: Inventory): Job {
+        // If no suspend operation is used in the flow, the fill will be done in the same thread & tick.
+        // That's why we start with unconfined dispatcher.
+        return fillScope(key).launch(Dispatchers.Unconfined) {
+            val size = inventory.size
+            val inventoryFlowItems = getItems(key, size).cancellable()
+
+            if (loadingAnimation == null) {
+                // Will fill the inventory bit by bit.
+                inventoryFlowItems.collect { (index, item) -> inventory.setItem(index, item) }
+            } else {
+                val loadingAnimationJob = launch { loadingAnimation.loading(key, inventory) }
+
+                // To avoid conflicts with the loading animation,
+                // we need to store the items in a temporary inventory
+                val temporaryInventory = arrayOfNulls<ItemStack>(size)
+
+                inventoryFlowItems
+                    .onCompletion { exception ->
+                        // When the flow is finished, we cancel the loading animation.
+                        loadingAnimationJob.cancelAndJoin()
+
+                        // If the flow was completed successfully, we fill the inventory with the temporary inventory.
+                        if (exception == null) {
+                            inventory.contents = temporaryInventory
+                        }
+                    }.collect { (index, item) -> temporaryInventory[index] = item }
+            }
+        }
+    }
+
+    /**
+     * Create the inventory for the key.
+     * @param key Key to create the inventory for.
+     * @return New created inventory.
      */
-    public abstract suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent)
+    protected abstract fun createInventory(key: T): Inventory
 
     /**
-     * Remove the client has a viewer of the GUI.
-     * @param client Client to close the GUI for.
-     * @param closeInventory If true, the interface will be closed, otherwise it will be kept open.
-     * @return True if the inventory was closed, false otherwise.
+     * Create a new flow of [Item][ItemStack] to fill the inventory with.
+     * ```kotlin
+     * flow {
+     *   emit(0 to ItemStack(Material.STONE))
+     *   delay(1.seconds) // simulate a suspend operation
+     *   emit(1 to ItemStack(Material.DIRT))
+     * }
+     * ```
+     * If the flow doesn't suspend the coroutine,
+     * the inventory will be filled in the same tick & thread than during the creation of the inventory.
+     * @param key Key to fill the inventory for.
+     * @param size Size of the inventory.
+     * @return Flow of [Item][ItemStack] with index.
      */
-    public abstract suspend fun close(client: Client, closeInventory: Boolean = true): Boolean
+    protected abstract fun getItems(key: T, size: Int): Flow<ItemStackIndex>
 
     /**
      * Check if the GUI contains the inventory.
      * @param inventory Inventory to check.
      * @return True if the GUI contains the inventory, false otherwise.
      */
-    public abstract suspend fun hasInventory(inventory: Inventory): Boolean
+    public open suspend fun hasInventory(inventory: Inventory): Boolean {
+        return mutex.withLock {
+            inventories.values.any { it.inventory == inventory }
+        }
+    }
+
+    /**
+     * Check if the inventory is loading.
+     * @param inventory Inventory to check.
+     * @return True if the inventory is loading (all the items are not loaded),
+     * false if the inventory is loaded or not present in the GUI.
+     */
+    public open suspend fun isInventoryLoading(inventory: Inventory): Boolean {
+        return mutex.withLock {
+            inventories.values.firstOrNull { it.inventory == inventory }?.isLoading == true
+        }
+    }
+
+    /**
+     * Get the viewers of the GUI.
+     * @return List of viewers.
+     */
+    public open suspend fun viewers(): Sequence<HumanEntity> {
+        return mutex.withLock {
+            unsafeViewers()
+        }
+    }
+
+    /**
+     * Get the viewers of the inventory.
+     * This function is not thread-safe.
+     * @return The viewers of the inventory.
+     */
+    protected open fun unsafeViewers(): Sequence<HumanEntity> {
+        return inventories.values.asSequence().map { it.inventory }.flatMap(Inventory::getViewers)
+    }
+
+    /**
+     * Check if the GUI contains the player.
+     * @param client Client to check.
+     * @return True if the GUI contains the player, false otherwise.
+     */
+    public open suspend fun contains(client: Client): Boolean {
+        return mutex.withLock {
+            unsafeContains(client)
+        }
+    }
+
+    /**
+     * Check if the GUI contains the client.
+     * This function is not thread-safe.
+     * @param client Client to check.
+     * @return True if the GUI contains the client, false otherwise.
+     */
+    protected open fun unsafeContains(client: Client): Boolean {
+        val player = client.player ?: return false
+        return unsafeViewers().any { it == player }
+    }
 
     /**
      * Close the inventory.
@@ -106,8 +294,27 @@ public abstract class GUI {
     public open suspend fun close() {
         isClosed = true
         unregister()
+
+        mutex.withLock {
+            inventories.values.forEach {
+                it.job.apply {
+                    cancel(GUIClosedException("The GUI is closing"))
+                    join()
+                }
+                it.inventory.close()
+            }
+            inventories.clear()
+        }
     }
 
+    /**
+     * Remove the client has a viewer of the GUI.
+     * @param client Client to close the GUI for.
+     * @param closeInventory If true, the interface will be closed, otherwise it will be kept open.
+     * @return True if the inventory was closed, false otherwise.
+     */
+    public abstract suspend fun close(client: Client, closeInventory: Boolean = true): Boolean
+
     /**
      * Verify that the GUI is open.
      * If the GUI is closed, throw an exception.
@@ -116,33 +323,35 @@ public abstract class GUI {
         if (isClosed) throw GUIClosedException("Cannot use a closed GUI")
     }
 
-    /**
-     * Get the viewers of the GUI.
-     * @return List of viewers.
-     */
-    public abstract suspend fun viewers(): List<HumanEntity>
-
-    /**
-     * Check if the GUI contains the player.
-     * @param client Client to check.
-     * @return True if the GUI contains the player, false otherwise.
-     */
-    public abstract suspend fun contains(client: Client): Boolean
-
     /**
      * Register the GUI to the listener.
      * @return True if the GUI was registered, false otherwise.
      */
-    protected fun register(): Boolean {
+    public open suspend fun register(): Boolean {
+        requireOpen()
         return manager.add(this)
     }
 
     /**
      * Unregister the GUI from the listener.
+     * Should be called when the GUI is closed with [close].
      * @return True if the GUI was unregistered, false otherwise.
      */
-    protected fun unregister(): Boolean {
+    protected open suspend fun unregister(): Boolean {
         return manager.remove(this)
     }
 
+    /**
+     * Action to do when the client clicks on an item in the inventory.
+     * @param client Client who clicked.
+     * @param clickedItem Item clicked by the client cannot be null or [AIR][Material.AIR]
+     * @param clickedInventory Inventory where the click was detected.
+     * @param event Event of the click.
+     */
+    public abstract suspend fun onClick(
+        client: Client,
+        clickedInventory: Inventory,
+        clickedItem: ItemStack,
+        event: InventoryClickEvent
+    )
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
index af3cebc9..8053552f 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
@@ -17,7 +17,6 @@ import org.bukkit.event.block.Action
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.event.player.PlayerInteractEvent
-import org.bukkit.event.player.PlayerQuitEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.PlayerInventory
@@ -42,8 +41,10 @@ public class GUIListener(private val plugin: Plugin) : Listener {
         if (event.isCancelled) return
 
         val item = event.currentItem
+        // If the item is null or air, we should ignore the click
         if (item == null || item.type == Material.AIR) return
 
+        // If the click is not in an inventory, this is not a GUI click
         val clickedInventory = event.clickedInventory ?: return
 
         val player = event.whoClicked
@@ -75,7 +76,7 @@ public class GUIListener(private val plugin: Plugin) : Listener {
 
         // The item in a GUI is not supposed to be moved
         event.cancel()
-        gui.onClick(client, item, event)
+        gui.onClick(client, clickedInventory, item, event)
     }
 
     /**
@@ -116,27 +117,10 @@ public class GUIListener(private val plugin: Plugin) : Listener {
      */
     @EventHandler
     public suspend fun onInventoryClose(event: InventoryCloseEvent) {
-        quitOpenedGUI(event.player)
-    }
-
-    /**
-     * Called when a player quits the server.
-     * If the player has a GUI opened, the GUI is notified that it is closed for this player.
-     * @param event Event of the quit.
-     */
-    @EventHandler
-    public suspend fun onPlayerQuit(event: PlayerQuitEvent) {
-        quitOpenedGUI(event.player)
-    }
-
-    /**
-     * Quit the opened GUI for the player.
-     * @param player Player to quit the GUI for.
-     */
-    private suspend fun quitOpenedGUI(player: HumanEntity) {
-        val client = clients.getClientOrNull(player)
+        val client = clients.getClientOrNull(event.player)
         val gui = client?.gui() ?: return
         // We don't close the inventory because it is closing due to event.
+        // That avoids an infinite loop of events and consequently a stack overflow.
         gui.close(client, false)
     }
 
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
index f110d828..fc720077 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIManager.kt
@@ -1,6 +1,8 @@
 package com.github.rushyverse.api.gui
 
 import com.github.rushyverse.api.player.Client
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 /**
  * Manages the GUIs for players within the game.
@@ -8,15 +10,20 @@ import com.github.rushyverse.api.player.Client
  */
 public class GUIManager {
 
+    /**
+     * Mutex used to ensure thread-safe operations.
+     */
+    private val mutex = Mutex()
+
     /**
      * Private mutable set storing GUIs.
      */
-    private val _guis = mutableSetOf<GUI>()
+    private val _guis = mutableSetOf<GUI<*>>()
 
     /**
      * Immutable view of the GUIs set.
      */
-    public val guis: Collection<GUI> get() = _guis
+    public val guis: Collection<GUI<*>> get() = _guis
 
     /**
      * Retrieves the GUI for the specified player.
@@ -25,8 +32,10 @@ public class GUIManager {
      * @param client The player for whom the GUI is to be retrieved or created.
      * @return The language associated with the player.
      */
-    public suspend fun get(client: Client): GUI? {
-        return _guis.firstOrNull { it.contains(client) }
+    public suspend fun get(client: Client): GUI<*>? {
+        return mutex.withLock {
+            guis.firstOrNull { it.contains(client) }
+        }
     }
 
     /**
@@ -34,8 +43,8 @@ public class GUIManager {
      * @param gui GUI to add.
      * @return True if the GUI was added, false otherwise.
      */
-    public fun add(gui: GUI): Boolean {
-        return _guis.add(gui)
+    public suspend fun add(gui: GUI<*>): Boolean {
+        return mutex.withLock { _guis.add(gui) }
     }
 
     /**
@@ -43,7 +52,7 @@ public class GUIManager {
      * @param gui GUI to remove.
      * @return True if the GUI was removed, false otherwise.
      */
-    public fun remove(gui: GUI): Boolean {
-        return _guis.remove(gui)
+    public suspend fun remove(gui: GUI<*>): Boolean {
+        return mutex.withLock { _guis.remove(gui) }
     }
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
index 9c004504..4eaf1977 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
@@ -1,9 +1,16 @@
 package com.github.rushyverse.api.gui
 
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
+import com.github.rushyverse.api.translation.SupportedLanguage
+import com.github.shynixn.mccoroutine.bukkit.scope
 import java.util.*
-import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.job
+import kotlinx.coroutines.plus
 import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.plugin.Plugin
 
 /**
  * GUI where a new inventory is created for each [locale][Locale].
@@ -12,22 +19,28 @@ import org.bukkit.event.inventory.InventoryCloseEvent
  * For example, if two players have the same language, they will share the same inventory.
  * If one of them changes their language, he will have another inventory dedicated to his new language.
  */
-public abstract class LocaleGUI : DedicatedGUI<Locale>() {
+public abstract class LocaleGUI(
+    protected val plugin: Plugin,
+    loadingAnimation: InventoryLoadingAnimation<Locale>? = null,
+    initialNumberInventories: Int = SupportedLanguage.entries.size
+) : GUI<Locale>(
+    loadingAnimation = loadingAnimation,
+    initialNumberInventories = initialNumberInventories
+) {
 
     override suspend fun getKey(client: Client): Locale {
         return client.lang().locale
     }
 
-    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
-        if (!closeInventory) {
-            return false
-        }
+    override suspend fun fillScope(key: Locale): CoroutineScope {
+        val scope = plugin.scope
+        return scope + SupervisorJob(scope.coroutineContext.job)
+    }
 
-        return mutex.withLock {
-            if (unsafeContains(client)) {
-                client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
-                true
-            } else false
-        }
+    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+        return if (closeInventory && contains(client)) {
+            client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
+            true
+        } else false
     }
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
index cd3524b9..d5a096fc 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
@@ -1,8 +1,12 @@
 package com.github.rushyverse.api.gui
 
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.job
+import kotlinx.coroutines.plus
 import kotlinx.coroutines.sync.withLock
-import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.InventoryHolder
 
@@ -10,19 +14,25 @@ import org.bukkit.inventory.InventoryHolder
  * GUI where a new inventory is created for each player.
  * An inventory is created when the player opens the GUI and he is not sharing the GUI with another player.
  */
-public abstract class PlayerGUI : DedicatedGUI<Client>() {
+public abstract class PlayerGUI(
+    loadingAnimation: InventoryLoadingAnimation<Client>? = null
+) : GUI<Client>(loadingAnimation = loadingAnimation) {
 
     override suspend fun getKey(client: Client): Client {
         return client
     }
 
+    override suspend fun fillScope(key: Client): CoroutineScope {
+        return key + SupervisorJob(key.coroutineContext.job)
+    }
+
     /**
      * Create the inventory for the client.
      * Will translate the title and fill the inventory.
      * @param key The client to create the inventory for.
      * @return The inventory for the client.
      */
-    override suspend fun createInventory(key: Client): Inventory {
+    override fun createInventory(key: Client): Inventory {
         val player = key.requirePlayer()
         return createInventory(player, key)
     }
@@ -42,11 +52,16 @@ public abstract class PlayerGUI : DedicatedGUI<Client>() {
     }
 
     override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
-        return mutex.withLock { inventories.remove(client) }?.run {
-            if (closeInventory) {
-                client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
-            }
-            true
-        } == true
+        val (inventory, job) = mutex.withLock { inventories.remove(client) } ?: return false
+
+        job.cancel(GUIClosedForClientException(client))
+        job.join()
+
+        if (closeInventory) {
+            // Call out of the lock to avoid slowing down the mutex.
+            inventory.close()
+        }
+
+        return true
     }
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
index 167c74d5..3ec24c71 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
@@ -1,86 +1,71 @@
 package com.github.rushyverse.api.gui
 
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import org.bukkit.entity.HumanEntity
+import com.github.shynixn.mccoroutine.bukkit.scope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.job
+import kotlinx.coroutines.plus
+import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.inventory.Inventory
+import org.bukkit.plugin.Plugin
 
 /**
  * GUI that can be shared by multiple players.
  * Only one inventory is created for all the viewers.
  * @property server Server.
  * @property viewers List of viewers.
- * @property inventory Inventory shared by all the viewers.
  */
-public abstract class SingleGUI : GUI() {
+public abstract class SingleGUI(
+    protected val plugin: Plugin,
+    loadingAnimation: InventoryLoadingAnimation<Any>? = null
+) : GUI<Any>(
+    loadingAnimation = loadingAnimation,
+    initialNumberInventories = 1
+) {
 
-    private var inventory: Inventory? = null
+    public companion object {
+        /**
+         * Unique key for the GUI.
+         * This GUI is shared by all the players, so the key is the same for all of them.
+         * That allows creating a unique inventory.
+         */
+        private val KEY = Any()
+    }
 
-    private val mutex = Mutex()
+    override suspend fun getKey(client: Client): Any {
+        return KEY
+    }
 
-    override suspend fun openGUI(client: Client): Boolean {
-        val player = client.requirePlayer()
-        val inventory = getOrCreateInventory()
-        player.openInventory(inventory)
-        return true
+    override suspend fun fillScope(key: Any): CoroutineScope {
+        val scope = plugin.scope
+        return scope + SupervisorJob(scope.coroutineContext.job)
     }
 
-    /**
-     * Get the inventory of the GUI.
-     * If the inventory is not created, create it.
-     * @return The inventory of the GUI.
-     */
-    private suspend fun getOrCreateInventory(): Inventory {
-        return mutex.withLock {
-            inventory ?: createInventory().also {
-                inventory = it
-                fill(it)
-            }
-        }
+    override fun createInventory(key: Any): Inventory {
+        return createInventory()
     }
 
     /**
-     * Create the inventory of the GUI.
-     * This function is called only once when the inventory is created.
-     * @return A new inventory.
+     * @see createInventory(key)
      */
     protected abstract fun createInventory(): Inventory
 
     override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
         return if (closeInventory && contains(client)) {
-            client.player?.closeInventory()
+            client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
             true
         } else false
     }
 
-    override suspend fun viewers(): List<HumanEntity> {
-        return mutex.withLock { inventory?.viewers } ?: emptyList()
-    }
-
-    override suspend fun contains(client: Client): Boolean {
-        return client.player?.let { it in viewers() } == true
-    }
-
-    override suspend fun hasInventory(inventory: Inventory): Boolean {
-        return mutex.withLock { this.inventory } == inventory
-    }
-
-    override suspend fun close() {
-        super.close()
-        mutex.withLock {
-            val inventory = inventory
-            if (inventory != null) {
-                inventory.close()
-                this.inventory = null
-            }
-        }
+    override fun getItems(key: Any, size: Int): Flow<ItemStackIndex> {
+        return getItems(size)
     }
 
     /**
-     * Fill the inventory with items for the client.
-     * This function is called when the inventory is created.
-     * @param inventory The inventory to fill.
+     * @see getItems(key, size)
      */
-    protected abstract suspend fun fill(inventory: Inventory)
+    protected abstract fun getItems(size: Int): Flow<ItemStackIndex>
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/load/InventoryLoadingAnimation.kt b/src/main/kotlin/com/github/rushyverse/api/gui/load/InventoryLoadingAnimation.kt
new file mode 100644
index 00000000..a6179f74
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/load/InventoryLoadingAnimation.kt
@@ -0,0 +1,18 @@
+package com.github.rushyverse.api.gui.load
+
+import org.bukkit.inventory.Inventory
+
+/**
+ * Animate an inventory while it is being loaded in the background.
+ * @param T Type of the key.
+ */
+public fun interface InventoryLoadingAnimation<T> {
+
+    /**
+     * Animate the inventory while the real inventory is being loaded in the background.
+     * @param key Key to animate the inventory for.
+     * @param inventory Inventory to animate.
+     * @return A job that can be cancelled to stop the animation.
+     */
+    public suspend fun loading(key: T, inventory: Inventory)
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
new file mode 100644
index 00000000..14f95f3e
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
@@ -0,0 +1,48 @@
+package com.github.rushyverse.api.gui.load
+
+import java.util.*
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+
+/**
+ * Animation that shifts the items in the inventory.
+ * The items are shifted by [shift] slots every [delay].
+ * The items are placed in the inventory by calling [initialize].
+ * If too few items are returned by [initialize], the remaining slots will be filled with null items.
+ * If too many items are returned by [initialize], the overflowing items will be ignored.
+ * @param T Type of the key.
+ * @property initialize Function that returns the sequence of items to place in the inventory.
+ * @property shift Number of slots to shift the items by.
+ * @property delay Delay between each shift.
+ */
+public class ShiftInventoryLoadingAnimation<T>(
+    private val initialize: (T) -> Sequence<ItemStack>,
+    private val shift: Int = 1,
+    private val delay: Duration = 100.milliseconds,
+) : InventoryLoadingAnimation<T> {
+
+    override suspend fun loading(key: T, inventory: Inventory) {
+        coroutineScope {
+            val size = inventory.size
+            val contents = arrayOfNulls<ItemStack>(size)
+            // Fill the inventory with the initial items.
+            // If the sequence is too short, it will be filled with null items.
+            // If the sequence is too long, the overflowing items will be ignored.
+            initialize(key).take(size).forEachIndexed { index, item ->
+                contents[index] = item
+            }
+
+            val contentList = contents.toMutableList()
+            while (isActive) {
+                inventory.contents = contentList.toTypedArray()
+                delay(delay)
+                Collections.rotate(contentList, shift)
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/com/github/rushyverse/api/player/Client.kt b/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
index bb6ff06f..22c9cefe 100644
--- a/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/player/Client.kt
@@ -81,6 +81,6 @@ public open class Client(
      * Get the opened GUI of the player.
      * @return The opened GUI of the player.
      */
-    public suspend fun gui(): GUI? = guiManager.get(this)
+    public suspend fun gui(): GUI<*>? = guiManager.get(this)
 
 }
diff --git a/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt b/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt
index df562752..fef9664c 100644
--- a/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/AbstractKoinTest.kt
@@ -5,6 +5,7 @@ import com.github.rushyverse.api.koin.loadModule
 import com.github.rushyverse.api.utils.randomString
 import io.mockk.every
 import io.mockk.mockk
+import io.mockk.unmockkAll
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import org.bukkit.Server
@@ -47,6 +48,7 @@ open class AbstractKoinTest {
     open fun onAfter() {
         CraftContext.stopKoin(pluginId)
         CraftContext.stopKoin(APIPlugin.ID_API)
+        unmockkAll()
     }
 
     fun loadTestModule(moduleDeclaration: ModuleDeclaration): Module =
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
new file mode 100644
index 00000000..abf9ff48
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
@@ -0,0 +1,373 @@
+package com.github.rushyverse.api.gui
+
+import be.seeseemelk.mockbukkit.MockBukkit
+import be.seeseemelk.mockbukkit.ServerMock
+import be.seeseemelk.mockbukkit.entity.PlayerMock
+import com.github.rushyverse.api.AbstractKoinTest
+import com.github.rushyverse.api.extension.ItemStack
+import com.github.rushyverse.api.player.Client
+import com.github.rushyverse.api.player.ClientManager
+import com.github.rushyverse.api.player.ClientManagerImpl
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.collections.shouldContainAll
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.bukkit.Material
+import org.bukkit.event.inventory.InventoryType
+import org.bukkit.inventory.ItemStack
+
+abstract class AbstractGUITest : AbstractKoinTest() {
+
+    protected lateinit var guiManager: GUIManager
+    protected lateinit var clientManager: ClientManager
+    protected lateinit var serverMock: ServerMock
+
+    @BeforeTest
+    override fun onBefore() {
+        super.onBefore()
+        guiManager = GUIManager()
+        clientManager = ClientManagerImpl()
+
+        loadApiTestModule {
+            single { guiManager }
+            single { clientManager }
+        }
+
+        serverMock = MockBukkit.mock()
+    }
+
+    @AfterTest
+    override fun onAfter() {
+        super.onAfter()
+        MockBukkit.unmock()
+    }
+
+    abstract inner class Register {
+
+        @Test
+        fun `should register if not already registered`() = runTest {
+            val gui = createNonFillGUI()
+            gui.register() shouldBe true
+            guiManager.guis shouldContainAll listOf(gui)
+        }
+
+        @Test
+        fun `should not register if already registered`() = runTest {
+            val gui = createNonFillGUI()
+            gui.register() shouldBe true
+            gui.register() shouldBe false
+            guiManager.guis shouldContainAll listOf(gui)
+        }
+
+        @Test
+        fun `should throw exception if GUI is closed`() = runTest {
+            val gui = createNonFillGUI()
+            gui.close()
+            shouldThrow<GUIClosedException> { gui.register() }
+        }
+    }
+
+    abstract inner class Viewers {
+
+        @Test
+        fun `should return empty list if no client is viewing the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            gui.viewers().toList() shouldBe emptyList()
+        }
+
+        @Test
+        fun `should return the list of clients viewing the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val playerClients = List(5) { registerPlayer() }
+
+            playerClients.forEach { (_, client) ->
+                gui.open(client) shouldBe true
+            }
+
+            gui.viewers().toList() shouldContainExactlyInAnyOrder playerClients.map { it.first }
+        }
+
+    }
+
+    abstract inner class Contains {
+
+        @Test
+        fun `should return false if the client is not viewing the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val (_, client) = registerPlayer()
+            gui.contains(client) shouldBe false
+        }
+
+        @Test
+        fun `should return true if the client is viewing the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val (_, client) = registerPlayer()
+            gui.open(client) shouldBe true
+            gui.contains(client) shouldBe true
+        }
+
+    }
+
+    abstract inner class Open {
+
+        @Test
+        fun `should throw exception if GUI is closed`() = runTest {
+            val gui = createNonFillGUI()
+            gui.close()
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+            shouldThrow<GUIClosedException> { gui.open(client) }
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should do nothing if the client has the same GUI opened`() = runTest {
+            val type = InventoryType.HOPPER
+            val gui = createNonFillGUI(inventoryType = type)
+            gui.register()
+            val (player, client) = registerPlayer()
+
+            gui.open(client) shouldBe true
+            player.assertInventoryView(type)
+
+            gui.open(client) shouldBe false
+            player.assertInventoryView(type)
+        }
+
+        @Test
+        fun `should do nothing if the player is dead`() = runTest {
+            val gui = createNonFillGUI()
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+
+            player.health = 0.0
+            gui.open(client) shouldBe false
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should fill the inventory in the same thread if no suspend operation`() {
+
+            val items: Array<ItemStack> = arrayOf(
+                ItemStack { type = Material.DIAMOND_ORE },
+                ItemStack { type = Material.STICK },
+            )
+
+            runBlocking {
+                val currentThread = Thread.currentThread()
+
+                val type = InventoryType.ENDER_CHEST
+                val gui = createFillGUI(items, delay = null, inventoryType = type)
+                gui.register()
+                val (player, client) = registerPlayer()
+
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
+
+                val inventory = player.openInventory.topInventory
+                gui.isInventoryLoading(inventory) shouldBe false
+
+                val content = inventory.contents
+                items.forEachIndexed { index, item ->
+                    content[index] shouldBe item
+                }
+
+                for (i in items.size until content.size) {
+                    content[i] shouldBe null
+                }
+
+                getFillThreadBeforeSuspend(gui) shouldBe currentThread
+                getFillThreadAfterSuspend(gui) shouldBe currentThread
+            }
+        }
+
+        @Test
+        fun `should fill the inventory in the other thread after suspend operation`() {
+
+            val items: Array<ItemStack> = arrayOf(
+                ItemStack { type = Material.DIAMOND_AXE },
+                ItemStack { type = Material.ACACIA_LEAVES },
+            )
+
+            runBlocking {
+                val currentThread = Thread.currentThread()
+
+                val type = InventoryType.ENDER_CHEST
+                val delay = 100.milliseconds
+                val gui = createFillGUI(items = items, delay = delay, inventoryType = type)
+                gui.register()
+                val (player, client) = registerPlayer()
+
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
+
+                val inventory = player.openInventory.topInventory
+                gui.isInventoryLoading(inventory) shouldBe true
+
+                val content = inventory.contents
+                content.forEach { it shouldBe null }
+
+                delay(delay * 2)
+                gui.isInventoryLoading(inventory) shouldBe false
+
+                items.forEachIndexed { index, item ->
+                    content[index] shouldBe item
+                }
+
+                for (i in items.size until content.size) {
+                    content[i] shouldBe null
+                }
+
+                getFillThreadBeforeSuspend(gui) shouldBe currentThread
+                getFillThreadAfterSuspend(gui) shouldNotBe currentThread
+            }
+        }
+
+    }
+
+    abstract inner class Close {
+
+        @Test
+        fun `should close all inventories and remove all viewers`() = runTest {
+            val type = InventoryType.BREWING
+            val gui = createNonFillGUI(type)
+            gui.register()
+
+            val playerClients = List(5) { registerPlayer() }
+            val initialInventoryViewType = playerClients.first().first.openInventory.type
+
+            playerClients.forEach { (player, client) ->
+                player.assertInventoryView(initialInventoryViewType)
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
+                client.gui() shouldBe gui
+            }
+
+            gui.close()
+            playerClients.forEach { (player, client) ->
+                player.assertInventoryView(initialInventoryViewType)
+                client.gui() shouldBe null
+            }
+        }
+
+        @Test
+        fun `should set isClosed to true`() = runTest {
+            val gui = createNonFillGUI()
+            gui.isClosed shouldBe false
+            gui.close()
+            gui.isClosed shouldBe true
+        }
+
+        @Test
+        fun `should unregister the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            gui.register()
+            guiManager.guis shouldContainAll listOf(gui)
+            gui.close()
+            guiManager.guis shouldContainAll listOf()
+        }
+
+        @Test
+        fun `should not be able to open the GUI after closing it`() = runTest {
+            val gui = createNonFillGUI()
+            gui.register()
+            val (_, client) = registerPlayer()
+            gui.close()
+
+            shouldThrow<GUIClosedException> {
+                gui.open(client)
+            }
+        }
+
+        @Test
+        fun `should not be able to register the GUI after closing it`() = runTest {
+            val gui = createNonFillGUI()
+            gui.close()
+            shouldThrow<GUIClosedException> {
+                gui.register()
+            }
+        }
+    }
+
+    abstract inner class CloseForClient {
+
+        @Test
+        fun `should return false if the client is not viewing the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+
+            player.assertInventoryView(initialInventoryViewType)
+            gui.close(client, true) shouldBe false
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should return true if the client is viewing the GUI`() = runTest {
+            val type = InventoryType.DISPENSER
+            val gui = createNonFillGUI(type)
+            val (player, client) = registerPlayer()
+
+            val initialInventoryViewType = player.openInventory.type
+
+            gui.open(client) shouldBe true
+            player.assertInventoryView(type)
+            gui.close(client, true) shouldBe true
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should not close for other clients`() = runTest {
+            val type = InventoryType.HOPPER
+            val gui = createNonFillGUI(type)
+            val (player, client) = registerPlayer()
+            val (player2, client2) = registerPlayer()
+            val initialInventoryViewType = player2.openInventory.type
+
+            gui.open(client) shouldBe true
+            gui.open(client2) shouldBe true
+
+            player.assertInventoryView(type)
+            player2.assertInventoryView(type)
+
+            gui.close(client2, true) shouldBe true
+            player.assertInventoryView(type)
+            player2.assertInventoryView(initialInventoryViewType)
+        }
+
+
+    }
+
+    abstract fun createNonFillGUI(inventoryType: InventoryType = InventoryType.HOPPER): GUI<*>
+
+    abstract fun createFillGUI(
+        items: Array<ItemStack>,
+        inventoryType: InventoryType = InventoryType.HOPPER,
+        delay: Duration? = null
+    ): GUI<*>
+
+    abstract fun getFillThreadBeforeSuspend(gui: GUI<*>): Thread?
+
+    abstract fun getFillThreadAfterSuspend(gui: GUI<*>): Thread?
+
+    protected suspend fun registerPlayer(): Pair<PlayerMock, Client> {
+        val player = serverMock.addPlayer()
+        val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
+        clientManager.put(player, client)
+        return player to client
+    }
+}
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 54900bb5..6d9f6e27 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -27,14 +27,12 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.test.runTest
-import net.kyori.adventure.text.Component
 import org.bukkit.Material
 import org.bukkit.entity.Player
 import org.bukkit.event.block.Action
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.event.player.PlayerInteractEvent
-import org.bukkit.event.player.PlayerQuitEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
@@ -80,7 +78,7 @@ class GUIListenerTest : AbstractKoinTest() {
             }
 
             callEvent(true, player, ItemStack { type = Material.DIRT }, player.inventory)
-            coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+            coVerify(exactly = 0) { gui.onClick(any(), any(), any(), any()) }
         }
 
         @Test
@@ -92,7 +90,7 @@ class GUIListenerTest : AbstractKoinTest() {
 
             suspend fun callEvent(item: ItemStack?) {
                 val event = callEvent(false, player, item, player.inventory)
-                coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+                coVerify(exactly = 0) { gui.onClick(any(), any(), any(), any()) }
                 verify(exactly = 0) { event.cancel() }
             }
 
@@ -114,7 +112,7 @@ class GUIListenerTest : AbstractKoinTest() {
             val item = ItemStack { type = Material.DIRT }
             callEvent(false, player, item, mockk())
 
-            coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+            coVerify(exactly = 0) { gui.onClick(any(), any(), any(), any()) }
             verify(exactly = 0) { pluginManager.callSuspendingEvent(any(), plugin) }
         }
 
@@ -136,7 +134,7 @@ class GUIListenerTest : AbstractKoinTest() {
             val item = ItemStack { type = Material.DIRT }
 
             callEvent(false, player, item, player.inventory)
-            coVerify(exactly = 0) { gui.onClick(any(), any(), any()) }
+            coVerify(exactly = 0) { gui.onClick(any(), any(), any(), any()) }
             verify(exactly = 1) { pluginManager.callSuspendingEvent(any(), plugin) }
             jobs.forEach { it.isCompleted shouldBe true }
 
@@ -153,13 +151,13 @@ class GUIListenerTest : AbstractKoinTest() {
             val inventory = mockk<Inventory>()
             val gui = registerGUI {
                 coEvery { contains(client) } returns true
-                coEvery { onClick(client, any(), any()) } returns Unit
+                coEvery { onClick(client, any(), any(), any()) } returns Unit
                 coEvery { hasInventory(inventory) } returns true
             }
 
             val item = ItemStack { type = Material.DIRT }
             val event = callEvent(false, player, item, inventory)
-            coVerify(exactly = 1) { gui.onClick(client, item, event) }
+            coVerify(exactly = 1) { gui.onClick(client, inventory, item, event) }
             verify(exactly = 1) { event.cancel() }
         }
 
@@ -183,7 +181,8 @@ class GUIListenerTest : AbstractKoinTest() {
 
     }
 
-    abstract inner class CloseGUIDuringEvent {
+    @Nested
+    inner class OnInventoryClose {
 
         @Test
         fun `should do nothing if client doesn't have a GUI opened`() = runTest {
@@ -192,9 +191,7 @@ class GUIListenerTest : AbstractKoinTest() {
                 coEvery { contains(client) } returns false
             }
 
-            val event = PlayerQuitEvent(player, Component.empty(), PlayerQuitEvent.QuitReason.DISCONNECTED)
-            listener.onPlayerQuit(event)
-
+            callEvent(player)
             coVerify(exactly = 0) { gui.close(client, any()) }
         }
 
@@ -216,14 +213,7 @@ class GUIListenerTest : AbstractKoinTest() {
             coVerify(exactly = 0) { gui2.close(client, any()) }
         }
 
-        protected abstract suspend fun callEvent(player: Player)
-
-    }
-
-    @Nested
-    inner class OnInventoryClose : CloseGUIDuringEvent() {
-
-        override suspend fun callEvent(player: Player) {
+        private suspend fun callEvent(player: Player) {
             val event = mockk<InventoryCloseEvent> {
                 every { getPlayer() } returns player
             }
@@ -231,17 +221,6 @@ class GUIListenerTest : AbstractKoinTest() {
         }
     }
 
-    @Nested
-    inner class OnPlayerQuit : CloseGUIDuringEvent() {
-
-        override suspend fun callEvent(player: Player) {
-            val event = mockk<PlayerQuitEvent> {
-                every { getPlayer() } returns player
-            }
-            listener.onPlayerQuit(event)
-        }
-    }
-
     private suspend fun registerPlayer(): Pair<Player, Client> {
         val player = serverMock.addPlayer()
         val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
@@ -249,8 +228,8 @@ class GUIListenerTest : AbstractKoinTest() {
         return player to client
     }
 
-    private inline fun registerGUI(block: GUI.() -> Unit): GUI {
-        val gui = mockk<GUI>(block = block)
+    private suspend inline fun registerGUI(block: GUI<*>.() -> Unit): GUI<*> {
+        val gui = mockk<GUI<*>>(block = block)
         guiManager.add(gui)
         return gui
     }
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt
index e861e595..04c2c6b0 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIManagerTest.kt
@@ -30,7 +30,7 @@ class GUIManagerTest {
         @Test
         fun `should returns null if no GUI contains the client`() = runTest {
             val client = mockk<Client>()
-            val gui = mockk<GUI> {
+            val gui = mockk<GUI<*>> {
                 coEvery { contains(any()) } returns false
             }
             manager.add(gui)
@@ -40,7 +40,7 @@ class GUIManagerTest {
         @Test
         fun `should returns GUI if contains the client`() = runTest {
             val client = mockk<Client>()
-            val gui = mockk<GUI> {
+            val gui = mockk<GUI<*>> {
                 coEvery { contains(client) } returns true
             }
             manager.add(gui)
@@ -51,7 +51,7 @@ class GUIManagerTest {
         fun `should returns GUI if contains the asked client`() = runTest {
             val client = mockk<Client>()
             val client2 = mockk<Client>()
-            val gui = mockk<GUI> {
+            val gui = mockk<GUI<*>> {
                 coEvery { contains(client) } returns true
                 coEvery { contains(client2) } returns false
             }
@@ -66,16 +66,16 @@ class GUIManagerTest {
     inner class Add {
 
         @Test
-        fun `should add non registered GUI`() {
-            val gui = mockk<GUI>()
+        fun `should add non registered GUI`() = runTest {
+            val gui = mockk<GUI<*>>()
             manager.add(gui) shouldBe true
             manager.guis.contains(gui) shouldBe true
             manager.guis.size shouldBe 1
         }
 
         @Test
-        fun `should not add registered GUI`() {
-            val gui = mockk<GUI>()
+        fun `should not add registered GUI`() = runTest {
+            val gui = mockk<GUI<*>>()
             manager.add(gui) shouldBe true
             manager.add(gui) shouldBe false
             manager.guis.contains(gui) shouldBe true
@@ -83,9 +83,9 @@ class GUIManagerTest {
         }
 
         @Test
-        fun `should add multiple GUIs`() {
-            val gui1 = mockk<GUI>()
-            val gui2 = mockk<GUI>()
+        fun `should add multiple GUIs`() = runTest {
+            val gui1 = mockk<GUI<*>>()
+            val gui2 = mockk<GUI<*>>()
             manager.add(gui1) shouldBe true
             manager.add(gui2) shouldBe true
             manager.guis.contains(gui1) shouldBe true
@@ -99,8 +99,8 @@ class GUIManagerTest {
     inner class Remove {
 
         @Test
-        fun `should remove registered GUI`() {
-            val gui = mockk<GUI>()
+        fun `should remove registered GUI`() = runTest {
+            val gui = mockk<GUI<*>>()
             manager.add(gui) shouldBe true
             manager.remove(gui) shouldBe true
             manager.guis.contains(gui) shouldBe false
@@ -108,17 +108,17 @@ class GUIManagerTest {
         }
 
         @Test
-        fun `should not remove non registered GUI`() {
-            val gui = mockk<GUI>()
+        fun `should not remove non registered GUI`() = runTest {
+            val gui = mockk<GUI<*>>()
             manager.remove(gui) shouldBe false
             manager.guis.contains(gui) shouldBe false
             manager.guis.size shouldBe 0
         }
 
         @Test
-        fun `should remove one GUI`() {
-            val gui1 = mockk<GUI>()
-            val gui2 = mockk<GUI>()
+        fun `should remove one GUI`() = runTest {
+            val gui1 = mockk<GUI<*>>()
+            val gui2 = mockk<GUI<*>>()
             manager.add(gui1) shouldBe true
             manager.add(gui2) shouldBe true
             manager.remove(gui1) shouldBe true
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
new file mode 100644
index 00000000..3e0fdce6
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
@@ -0,0 +1,226 @@
+package com.github.rushyverse.api.gui
+
+import be.seeseemelk.mockbukkit.ServerMock
+import com.github.rushyverse.api.player.Client
+import com.github.rushyverse.api.player.language.LanguageManager
+import com.github.rushyverse.api.translation.SupportedLanguage
+import com.github.shynixn.mccoroutine.bukkit.scope
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNotBe
+import io.mockk.every
+import io.mockk.mockkStatic
+import java.util.*
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.minutes
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.inventory.InventoryType
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+import org.bukkit.plugin.Plugin
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+
+class LocalePlayerGUITest : AbstractGUITest() {
+
+    private lateinit var languageManager: LanguageManager
+
+    @BeforeTest
+    override fun onBefore() {
+        super.onBefore()
+        languageManager = LanguageManager()
+
+        loadApiTestModule {
+            single { languageManager }
+        }
+
+        mockkStatic("com.github.shynixn.mccoroutine.bukkit.MCCoroutineKt")
+        every { plugin.scope } returns CoroutineScope(EmptyCoroutineContext)
+    }
+
+    override fun createFillGUI(items: Array<ItemStack>, inventoryType: InventoryType, delay: Duration?): GUI<*> {
+        return LocaleFillGUI(plugin, serverMock, inventoryType, items, delay)
+    }
+
+    override fun createNonFillGUI(inventoryType: InventoryType): GUI<*> {
+        return LocaleNonFillGUI(plugin, serverMock, inventoryType)
+    }
+
+    override fun getFillThreadAfterSuspend(gui: GUI<*>): Thread? {
+        return (gui as LocaleFillGUI).newThread
+    }
+
+    override fun getFillThreadBeforeSuspend(gui: GUI<*>): Thread? {
+        return (gui as LocaleFillGUI).calledThread
+    }
+
+    @Nested
+    inner class Register : AbstractGUITest.Register()
+
+    @Nested
+    inner class Viewers : AbstractGUITest.Viewers()
+
+    @Nested
+    inner class Contains : AbstractGUITest.Contains()
+
+    @Nested
+    inner class Open : AbstractGUITest.Open() {
+
+        @Test
+        fun `should create a new inventory according to the language client`() = runTest {
+            val type = InventoryType.HOPPER
+            val gui = createNonFillGUI(type)
+            val (player, client) = registerPlayer()
+            val (player2, client2) = registerPlayer()
+            languageManager.set(player, SupportedLanguage.ENGLISH)
+            languageManager.set(player2, SupportedLanguage.FRENCH)
+
+            gui.open(client) shouldBe true
+            gui.open(client2) shouldBe true
+
+            player.assertInventoryView(type)
+            player2.assertInventoryView(type)
+
+            player.openInventory.topInventory shouldNotBe player2.openInventory.topInventory
+        }
+
+        @Test
+        fun `should use the same inventory according to the language client`() = runTest {
+            val type = InventoryType.DISPENSER
+            val gui = createNonFillGUI(type)
+            val (player, client) = registerPlayer()
+            val (player2, client2) = registerPlayer()
+            languageManager.set(player, SupportedLanguage.FRENCH)
+            languageManager.set(player2, SupportedLanguage.FRENCH)
+
+            gui.open(client) shouldBe true
+            gui.open(client2) shouldBe true
+
+            player.assertInventoryView(type)
+            player2.assertInventoryView(type)
+
+            player.openInventory.topInventory shouldBe player2.openInventory.topInventory
+        }
+
+        @Test
+        fun `should not create a new inventory for the same client if previously closed`() = runTest {
+            val type = InventoryType.BREWING
+            val gui = createNonFillGUI(type)
+            val (player, client) = registerPlayer()
+
+            gui.open(client) shouldBe true
+            val firstInventory = player.openInventory.topInventory
+
+            gui.close(client, true) shouldBe true
+
+            gui.open(client) shouldBe true
+            player.openInventory.topInventory shouldBe firstInventory
+
+            player.assertInventoryView(type)
+        }
+
+    }
+
+    @Nested
+    inner class Close : AbstractGUITest.Close()
+
+    @Nested
+    inner class CloseForClient : AbstractGUITest.CloseForClient() {
+
+        @ParameterizedTest
+        @ValueSource(booleans = [true, false])
+        fun `should not stop loading the inventory if the client is viewing the GUI`(closeInventory: Boolean) {
+            runBlocking {
+                val type = InventoryType.HOPPER
+                val gui = createFillGUI(emptyArray(), delay = 10.minutes, inventoryType = type)
+                gui.register()
+                val (player, client) = registerPlayer()
+
+                val initialInventoryViewType = player.openInventory.type
+
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
+
+                val openInventory = player.openInventory
+                val inventory = openInventory.topInventory
+                gui.isInventoryLoading(inventory) shouldBe true
+
+                gui.close(client, closeInventory) shouldBe closeInventory
+                gui.isInventoryLoading(inventory) shouldBe true
+
+                if (closeInventory) {
+                    player.assertInventoryView(initialInventoryViewType)
+                    gui.contains(client) shouldBe false
+                } else {
+                    player.assertInventoryView(type)
+                    gui.contains(client) shouldBe true
+                }
+            }
+        }
+    }
+}
+
+private abstract class AbstractLocaleGUITest(
+    plugin: Plugin,
+    val serverMock: ServerMock,
+    val type: InventoryType = InventoryType.HOPPER
+) : LocaleGUI(plugin) {
+
+    override fun createInventory(key: Locale): Inventory {
+        return serverMock.createInventory(null, type)
+    }
+
+    override suspend fun onClick(
+        client: Client,
+        clickedInventory: Inventory,
+        clickedItem: ItemStack,
+        event: InventoryClickEvent
+    ) {
+        error("Should not be called")
+    }
+}
+
+private class LocaleNonFillGUI(
+    plugin: Plugin,
+    serverMock: ServerMock,
+    type: InventoryType
+) : AbstractLocaleGUITest(plugin, serverMock, type) {
+
+    override fun getItems(key: Locale, size: Int): Flow<ItemStackIndex> {
+        return emptyFlow()
+    }
+}
+
+private class LocaleFillGUI(
+    plugin: Plugin,
+    serverMock: ServerMock,
+    type: InventoryType,
+    val items: Array<ItemStack>,
+    val delay: Duration?
+) : AbstractLocaleGUITest(plugin, serverMock, type) {
+
+    var calledThread: Thread? = null
+
+    var newThread: Thread? = null
+
+    override fun getItems(key: Locale, size: Int): Flow<ItemStackIndex> {
+        calledThread = Thread.currentThread()
+        return flow {
+            delay?.let { delay(it) }
+            items.forEachIndexed { index, item ->
+                emit(index to item)
+            }
+            newThread = Thread.currentThread()
+        }
+    }
+}
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
index 949d4d15..6f5877d4 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
@@ -1,309 +1,192 @@
 package com.github.rushyverse.api.gui
 
-import be.seeseemelk.mockbukkit.MockBukkit
 import be.seeseemelk.mockbukkit.ServerMock
-import be.seeseemelk.mockbukkit.entity.PlayerMock
-import com.github.rushyverse.api.AbstractKoinTest
-import com.github.rushyverse.api.extension.ItemStack
 import com.github.rushyverse.api.player.Client
-import com.github.rushyverse.api.player.ClientManager
-import com.github.rushyverse.api.player.ClientManagerImpl
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.matchers.collections.shouldContainAll
-import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
-import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.test.AfterTest
-import kotlin.test.BeforeTest
 import kotlin.test.Test
+import kotlin.time.Duration
 import kotlin.time.Duration.Companion.minutes
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
-import org.bukkit.Material
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.InventoryHolder
 import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
 
-class PlayerGUITest : AbstractKoinTest() {
-
-    private lateinit var guiManager: GUIManager
-    private lateinit var clientManager: ClientManager
-    private lateinit var serverMock: ServerMock
-
-    @BeforeTest
-    override fun onBefore() {
-        super.onBefore()
-        guiManager = GUIManager()
-        clientManager = ClientManagerImpl()
-
-        loadApiTestModule {
-            single { guiManager }
-            single { clientManager }
-        }
-
-        serverMock = MockBukkit.mock()
-    }
-
-    @AfterTest
-    override fun onAfter() {
-        super.onAfter()
-        MockBukkit.unmock()
-    }
+class PlayerGUITest : AbstractGUITest() {
 
     @Nested
-    inner class Open {
-
-        @Test
-        fun `should throw exception if GUI is closed`() = runTest {
-            val gui = TestGUI(serverMock)
-            gui.close()
-            val (player, client) = registerPlayer()
-
-            val initialInventoryViewType = player.openInventory.type
-            shouldThrow<GUIClosedException> { gui.open(client) }
-            player.assertInventoryView(initialInventoryViewType)
-        }
+    inner class Register : AbstractGUITest.Register()
 
-        @Test
-        fun `should do nothing if the client has the same GUI opened`() = runTest {
-            val gui = TestGUI(serverMock)
-            val (player, client) = registerPlayer()
-
-            gui.open(client) shouldBe true
-            player.assertInventoryView(gui.type)
-
-            gui.open(client) shouldBe false
-            player.assertInventoryView(gui.type)
-        }
-
-        @Test
-        fun `should close the previous GUI if the client has one opened`() = runTest {
-            val gui = TestGUI(serverMock, InventoryType.ENDER_CHEST)
-            val (player, client) = registerPlayer()
-
-            gui.open(client) shouldBe true
-            player.assertInventoryView(gui.type)
-
-            val gui2 = TestGUI(serverMock, InventoryType.CHEST)
-            gui2.open(client) shouldBe true
-            player.assertInventoryView(gui2.type)
-            gui.contains(client) shouldBe false
-            gui2.contains(client) shouldBe true
-        }
-
-        @Test
-        fun `should do nothing if the player is dead`() = runTest {
-            val gui = TestGUI(serverMock)
-            val (player, client) = registerPlayer()
+    @Nested
+    inner class Viewers : AbstractGUITest.Viewers()
 
-            val initialInventoryViewType = player.openInventory.type
+    @Nested
+    inner class Contains : AbstractGUITest.Contains()
 
-            player.damage(Double.MAX_VALUE)
-            gui.open(client) shouldBe false
-            player.assertInventoryView(initialInventoryViewType)
-        }
+    @Nested
+    inner class Open : AbstractGUITest.Open() {
 
         @Test
         fun `should create a new inventory for the client`() = runTest {
-            val gui = TestGUI(serverMock)
+            val type = InventoryType.ENDER_CHEST
+            val gui = createNonFillGUI(type)
             val (player, client) = registerPlayer()
             val (player2, client2) = registerPlayer()
 
             gui.open(client) shouldBe true
             gui.open(client2) shouldBe true
 
-            player.assertInventoryView(gui.type)
-            player2.assertInventoryView(gui.type)
+            player.assertInventoryView(type)
+            player2.assertInventoryView(type)
 
             player.openInventory.topInventory shouldNotBe player2.openInventory.topInventory
         }
 
         @Test
-        fun `should fill the inventory`() = runTest {
-            val gui = TestFilledGUI(serverMock)
+        fun `should create a new inventory for the same client if previous is closed before`() = runTest {
+            val type = InventoryType.BREWING
+            val gui = createNonFillGUI(type)
             val (player, client) = registerPlayer()
 
             gui.open(client) shouldBe true
-            player.assertInventoryView(InventoryType.CHEST)
-
-            val inventory = player.openInventory.topInventory
-            val content = inventory.contents
-            println(content.contentToString())
-            content[0]!!.type shouldBe Material.DIAMOND_ORE
-            content[1]!!.type shouldBe Material.STICK
-
-            for (i in 2 until content.size) {
-                content[i] shouldBe null
-            }
-        }
-
-    }
+            val firstInventory = player.openInventory.topInventory
 
-    @Nested
-    inner class Viewers {
-
-        @Test
-        fun `should return empty list if no client is viewing the GUI`() = runTest {
-            val gui = TestGUI(serverMock)
-            gui.viewers() shouldBe emptyList()
-        }
-
-        @Test
-        fun `should return the list of clients viewing the GUI`() = runTest {
-            val gui = TestGUI(serverMock)
-            val playerClients = List(5) { registerPlayer() }
+            gui.close(client, true) shouldBe true
 
-            playerClients.forEach { (_, client) ->
-                gui.open(client) shouldBe true
-            }
+            gui.open(client) shouldBe true
+            player.openInventory.topInventory shouldNotBe firstInventory
 
-            gui.viewers() shouldContainExactlyInAnyOrder playerClients.map { it.first }
+            player.assertInventoryView(type)
         }
-
     }
 
     @Nested
-    inner class Contains {
-
-        @Test
-        fun `should return false if the client is not viewing the GUI`() = runTest {
-            val gui = TestGUI(serverMock)
-            val (_, client) = registerPlayer()
-            gui.contains(client) shouldBe false
-        }
-
-        @Test
-        fun `should return true if the client is viewing the GUI`() = runTest {
-            val gui = TestGUI(serverMock)
-            val (_, client) = registerPlayer()
-            gui.open(client) shouldBe true
-            gui.contains(client) shouldBe true
-        }
-
-    }
+    inner class Close : AbstractGUITest.Close()
 
     @Nested
-    inner class CloseForClient {
-
-        @Test
-        fun `should return false if the client is not viewing the GUI`() = runTest(timeout = 1.minutes) {
-            val gui = TestGUI(serverMock)
-            val (player, client) = registerPlayer()
+    inner class CloseForClient : AbstractGUITest.CloseForClient() {
+
+        @ParameterizedTest
+        @ValueSource(booleans = [true, false])
+        fun `should stop loading the inventory if the client is viewing the GUI`(closeInventory: Boolean) {
+            runBlocking {
+                val type = InventoryType.DROPPER
+                val gui = createFillGUI(items = emptyArray(), inventoryType = type, delay = 10.minutes)
+                gui.register()
+                val (player, client) = registerPlayer()
 
-            val initialInventoryViewType = player.openInventory.type
+                val initialInventoryViewType = player.openInventory.type
 
-            player.assertInventoryView(initialInventoryViewType)
-            gui.close(client, true) shouldBe false
-            player.assertInventoryView(initialInventoryViewType)
-        }
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
 
-        @Test
-        fun `should close the inventory if the client is viewing the GUI`() = runTest(timeout = 1.minutes) {
-            val gui = TestGUI(serverMock)
-            val (player, client) = registerPlayer()
+                val openInventory = player.openInventory
+                val inventory = openInventory.topInventory
+                gui.isInventoryLoading(inventory) shouldBe true
 
-            val initialInventoryViewType = player.openInventory.type
+                gui.close(client, closeInventory) shouldBe true
+                gui.isInventoryLoading(inventory) shouldBe false
 
-            gui.open(client) shouldBe true
-            player.assertInventoryView(gui.type)
-            gui.close(client, true) shouldBe true
-            player.assertInventoryView(initialInventoryViewType)
+                if (closeInventory) {
+                    player.assertInventoryView(initialInventoryViewType)
+                } else {
+                    player.assertInventoryView(type)
+                }
+            }
         }
 
         @Test
         fun `should remove client inventory without closing it if closeInventory is false`() =
-            runTest(timeout = 1.minutes) {
-                val gui = TestGUI(serverMock)
+            runTest {
+                val type = InventoryType.ENDER_CHEST
+                val gui = NonFillGUI(serverMock, type = type)
                 val (player, client) = registerPlayer()
 
                 gui.open(client) shouldBe true
-                player.assertInventoryView(gui.type)
+                player.assertInventoryView(type)
+
                 gui.close(client, false) shouldBe true
-                player.assertInventoryView(gui.type)
+                player.assertInventoryView(type)
+
                 gui.contains(client) shouldBe false
             }
-
     }
 
-    @Nested
-    inner class Close {
-
-        @Test
-        fun `should close all inventories and remove all viewers`() = runTest(timeout = 1.minutes) {
-            val gui = TestGUI(serverMock, InventoryType.BREWING)
-
-            val playerClients = List(5) { registerPlayer() }
-            val initialInventoryViewType = playerClients.first().first.openInventory.type
-
-            playerClients.forEach { (player, client) ->
-                player.assertInventoryView(initialInventoryViewType)
-                gui.open(client) shouldBe true
-                player.assertInventoryView(gui.type)
-                client.gui() shouldBe gui
-            }
-
-            gui.close()
-            playerClients.forEach { (player, client) ->
-                player.assertInventoryView(initialInventoryViewType)
-                client.gui() shouldBe null
-            }
-        }
-
-        @Test
-        fun `should set isClosed to true`() = runTest {
-            val gui = TestGUI(serverMock)
-            gui.isClosed shouldBe false
-            gui.close()
-            gui.isClosed shouldBe true
-        }
+    override fun createNonFillGUI(inventoryType: InventoryType): GUI<*> {
+        return NonFillGUI(serverMock, inventoryType)
+    }
 
-        @Test
-        fun `should unregister the GUI`() = runTest {
-            val gui = TestGUI(serverMock)
-            guiManager.guis shouldContainAll listOf(gui)
-            gui.close()
-            guiManager.guis shouldContainAll listOf()
-        }
+    override fun createFillGUI(items: Array<ItemStack>, inventoryType: InventoryType, delay: Duration?): GUI<*> {
+        return FillGUI(serverMock, inventoryType, items, delay)
+    }
 
+    override fun getFillThreadBeforeSuspend(gui: GUI<*>): Thread? {
+        return (gui as FillGUI).calledThread
     }
 
-    private suspend fun registerPlayer(): Pair<PlayerMock, Client> {
-        val player = serverMock.addPlayer()
-        val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
-        clientManager.put(player, client)
-        return player to client
+    override fun getFillThreadAfterSuspend(gui: GUI<*>): Thread? {
+        return (gui as FillGUI).newThread
     }
 }
 
-private class TestGUI(val serverMock: ServerMock, val type: InventoryType = InventoryType.HOPPER) : PlayerGUI() {
+private abstract class AbstractPlayerGUITest(
+    val serverMock: ServerMock,
+    val type: InventoryType
+) : PlayerGUI() {
+
     override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
         return serverMock.createInventory(owner, type)
     }
 
-    override suspend fun fill(client: Client, inventory: Inventory) {
-        // Do nothing
-    }
-
-    override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
+    override suspend fun onClick(
+        client: Client,
+        clickedInventory: Inventory,
+        clickedItem: ItemStack,
+        event: InventoryClickEvent
+    ) {
         error("Should not be called")
     }
 }
 
-private class TestFilledGUI(val serverMock: ServerMock) : PlayerGUI() {
-    override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
-        return serverMock.createInventory(owner, InventoryType.CHEST)
-    }
+private class NonFillGUI(
+    serverMock: ServerMock,
+    type: InventoryType
+) : AbstractPlayerGUITest(serverMock, type) {
 
-    override suspend fun fill(client: Client, inventory: Inventory) {
-        inventory.setItem(0, ItemStack { type = Material.DIAMOND_ORE })
-        inventory.setItem(1, ItemStack { type = Material.STICK })
+    override fun getItems(key: Client, size: Int): Flow<ItemStackIndex> {
+        return emptyFlow()
     }
+}
 
-    override suspend fun onClick(client: Client, clickedItem: ItemStack, event: InventoryClickEvent) {
-        error("Should not be called")
+private class FillGUI(
+    serverMock: ServerMock,
+    type: InventoryType,
+    val items: Array<ItemStack>,
+    val delay: Duration?
+) : AbstractPlayerGUITest(serverMock, type) {
+
+    var calledThread: Thread? = null
+
+    var newThread: Thread? = null
+
+    override fun getItems(key: Client, size: Int): Flow<ItemStackIndex> {
+        calledThread = Thread.currentThread()
+        return flow {
+            delay?.let { delay(it) }
+            items.forEachIndexed { index, item ->
+                emit(index to item)
+            }
+            newThread = Thread.currentThread()
+        }
     }
 }
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
new file mode 100644
index 00000000..0cd3c26f
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -0,0 +1,195 @@
+package com.github.rushyverse.api.gui
+
+import be.seeseemelk.mockbukkit.ServerMock
+import com.github.rushyverse.api.player.Client
+import com.github.shynixn.mccoroutine.bukkit.scope
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockkStatic
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.minutes
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.inventory.InventoryType
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+import org.bukkit.plugin.Plugin
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+
+class SingleGUITest : AbstractGUITest() {
+
+    @BeforeTest
+    override fun onBefore() {
+        super.onBefore()
+        mockkStatic("com.github.shynixn.mccoroutine.bukkit.MCCoroutineKt")
+        every { plugin.scope } returns CoroutineScope(EmptyCoroutineContext)
+    }
+
+    override fun createNonFillGUI(inventoryType: InventoryType): GUI<*> {
+        return SingleNonFillGUI(plugin, serverMock, inventoryType)
+    }
+
+    override fun createFillGUI(items: Array<ItemStack>, inventoryType: InventoryType, delay: Duration?): GUI<*> {
+        return SingleFillGUI(plugin, serverMock, inventoryType, items, delay)
+    }
+
+    override fun getFillThreadBeforeSuspend(gui: GUI<*>): Thread? {
+        return (gui as SingleFillGUI).calledThread
+    }
+
+    override fun getFillThreadAfterSuspend(gui: GUI<*>): Thread? {
+        return (gui as SingleFillGUI).newThread
+    }
+
+    @Nested
+    inner class Register : AbstractGUITest.Register()
+
+    @Nested
+    inner class Viewers : AbstractGUITest.Viewers()
+
+    @Nested
+    inner class Contains : AbstractGUITest.Contains()
+
+    @Nested
+    inner class Open : AbstractGUITest.Open() {
+
+        @Test
+        fun `should use the same inventory for all clients`() = runTest {
+            val type = InventoryType.ENDER_CHEST
+            val gui = createNonFillGUI(type)
+            val inventories = List(5) {
+                val (player, client) = registerPlayer()
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
+
+                player.openInventory.topInventory
+            }
+
+            inventories.all { it === inventories.first() } shouldBe true
+        }
+
+        @Test
+        fun `should not create a new inventory for the same client if previously closed`() = runTest {
+            val type = InventoryType.BREWING
+            val gui = createNonFillGUI(type)
+            val (player, client) = registerPlayer()
+
+            gui.open(client) shouldBe true
+            val firstInventory = player.openInventory.topInventory
+
+            gui.close(client, true) shouldBe true
+
+            gui.open(client) shouldBe true
+            player.openInventory.topInventory shouldBe firstInventory
+
+            player.assertInventoryView(type)
+        }
+    }
+
+    @Nested
+    inner class Close : AbstractGUITest.Close()
+
+    @Nested
+    inner class CloseForClient : AbstractGUITest.CloseForClient() {
+
+        @ParameterizedTest
+        @ValueSource(booleans = [true, false])
+        fun `should not stop loading the inventory if the client is viewing the GUI`(closeInventory: Boolean) {
+            runBlocking {
+                val type = InventoryType.DROPPER
+                val gui = createFillGUI(emptyArray(), delay = 10.minutes, inventoryType = type)
+                gui.register()
+                val (player, client) = registerPlayer()
+
+                val initialInventoryViewType = player.openInventory.type
+
+                gui.open(client) shouldBe true
+                player.assertInventoryView(type)
+
+                val openInventory = player.openInventory
+                val inventory = openInventory.topInventory
+                gui.isInventoryLoading(inventory) shouldBe true
+
+                gui.close(client, closeInventory) shouldBe closeInventory
+                gui.isInventoryLoading(inventory) shouldBe true
+
+                if (closeInventory) {
+                    player.assertInventoryView(initialInventoryViewType)
+                    gui.contains(client) shouldBe false
+                } else {
+                    player.assertInventoryView(type)
+                    gui.contains(client) shouldBe true
+                }
+            }
+        }
+
+    }
+}
+
+private abstract class AbstractSingleGUITest(
+    plugin: Plugin,
+    val serverMock: ServerMock,
+    val type: InventoryType
+) : SingleGUI(plugin) {
+
+    override fun createInventory(): Inventory {
+        return serverMock.createInventory(null, type)
+    }
+
+    override suspend fun onClick(
+        client: Client,
+        clickedInventory: Inventory,
+        clickedItem: ItemStack,
+        event: InventoryClickEvent
+    ) {
+        error("Should not be called")
+    }
+
+}
+
+private class SingleNonFillGUI(
+    plugin: Plugin,
+    serverMock: ServerMock,
+    type: InventoryType
+) : AbstractSingleGUITest(plugin, serverMock, type) {
+
+    override fun getItems(size: Int): Flow<ItemStackIndex> {
+        return emptyFlow()
+    }
+
+}
+
+private class SingleFillGUI(
+    plugin: Plugin,
+    serverMock: ServerMock,
+    type: InventoryType,
+    val items: Array<ItemStack>,
+    val delay: Duration?
+) : AbstractSingleGUITest(plugin, serverMock, type) {
+
+    var calledThread: Thread? = null
+
+    var newThread: Thread? = null
+
+    override fun getItems(size: Int): Flow<ItemStackIndex> {
+        calledThread = Thread.currentThread()
+        return flow {
+            delay?.let { delay(it) }
+            items.forEachIndexed { index, item ->
+                emit(index to item)
+            }
+            newThread = Thread.currentThread()
+        }
+    }
+}
diff --git a/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt b/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt
index 7d356af7..205eb4cc 100644
--- a/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/player/ClientTest.kt
@@ -10,13 +10,17 @@ import com.github.rushyverse.api.player.exception.PlayerNotFoundException
 import io.kotest.matchers.shouldBe
 import io.mockk.coEvery
 import io.mockk.mockk
-import kotlinx.coroutines.CoroutineScope
-import org.junit.jupiter.api.assertThrows
 import java.util.*
 import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.test.*
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.test.runTest
 import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.assertThrows
 
 class ClientTest : AbstractKoinTest() {
 
@@ -75,7 +79,7 @@ class ClientTest : AbstractKoinTest() {
     }
 
     @Nested
-    inner class GetGUI  {
+    inner class GetGUI {
 
         @Test
         fun `get GUI returns null if no GUI is registered`() = runTest {
@@ -86,7 +90,7 @@ class ClientTest : AbstractKoinTest() {
         @Test
         fun `get GUI returns null if no GUI contains the client`() = runTest {
             val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
-            val gui = mockk<GUI> {
+            val gui = mockk<GUI<*>> {
                 coEvery { contains(client) } returns false
             }
             guiManager.add(gui)
@@ -96,7 +100,7 @@ class ClientTest : AbstractKoinTest() {
         @Test
         fun `get GUI returns GUI if contains the client`() = runTest {
             val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
-            val gui = mockk<GUI> {
+            val gui = mockk<GUI<*>> {
                 coEvery { contains(client) } returns true
             }
             guiManager.add(gui)

From 67786706425c1578090e3a9ddef3fc08d83afec6 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 11:00:06 +0100
Subject: [PATCH 24/50] feat: Implement update function

---
 .../com/github/rushyverse/api/gui/GUI.kt      | 49 ++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 9f037538..ae5ad80c 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -55,6 +55,11 @@ public open class GUIException(message: String) : CancellationException(message)
  */
 public class GUIClosedException(message: String) : GUIException(message)
 
+/**
+ * Exception thrown when the GUI is updating.
+ */
+public class GUIUpdatedException(message: String) : GUIException(message)
+
 /**
  * Exception thrown when the GUI is closed for a specific client.
  * @property client Client for which the GUI is closed.
@@ -106,7 +111,7 @@ public abstract class GUI<T>(
      * @param client Client to open the GUI for.
      * @return True if the GUI was opened, false otherwise.
      */
-    public suspend fun open(client: Client): Boolean {
+    public open suspend fun open(client: Client): Boolean {
         requireOpen()
 
         val player = client.player
@@ -139,6 +144,48 @@ public abstract class GUI<T>(
         return true
     }
 
+    /**
+     * Update the opened inventory for the client.
+     *
+     * If the client has the GUI opened, the inventory will be updated.
+     * If the client has another GUI opened, do nothing.
+     *
+     * Call [getItems] to get the new items to fill the inventory.
+     * @param client Client to update the inventory for.
+     * @param interruptLoading If true and if the inventory is loading, the loading will be interrupted
+     * to start a new loading animation.
+     * @return True if the inventory was updated, false otherwise.
+     * @see [getItems]
+     */
+    public open suspend fun update(client: Client, interruptLoading: Boolean = false): Boolean {
+        return mutex.withLock {
+            val key = getKey(client)
+            val inventoryData = inventories[key] ?: return@withLock false
+
+            // If the client doesn't have the GUI opened, do nothing.
+            if (!unsafeContains(client)) return@withLock false
+
+            if (inventoryData.isLoading) {
+                // If we don't want to interrupt the loading and the inventory is loading, do nothing.
+                if (!interruptLoading) return@withLock false
+                else {
+                    // If we want to interrupt the loading, we cancel the loading job.
+                    // We need to wait for the job to be cancelled to avoid conflicts with the new loading animation.
+                    inventoryData.job.apply {
+                        cancel(GUIUpdatedException("The GUI is updating"))
+                        join()
+                    }
+                }
+            }
+
+            val inventory = inventoryData.inventory
+            // Begin a new loading job and replace the old one.
+            val newLoadingJob = startLoadingInventory(key, inventory)
+            inventories[key] = InventoryData(inventory, newLoadingJob)
+            true
+        }
+    }
+
     /**
      * Get the inventory for the key.
      * If the inventory does not exist, create it.

From d25ea07d139b0159180f5a2446de34f54c5b1a96 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 16:01:15 +0100
Subject: [PATCH 25/50] test: Add tests about update method

---
 .../com/github/rushyverse/api/gui/GUI.kt      |  30 ++---
 .../rushyverse/api/gui/AbstractGUITest.kt     | 117 ++++++++++++------
 .../rushyverse/api/gui/LocalePlayerGUITest.kt |   3 +
 .../rushyverse/api/gui/PlayerGUITest.kt       |   3 +
 .../rushyverse/api/gui/SingleGUITest.kt       |   3 +
 5 files changed, 101 insertions(+), 55 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index ae5ad80c..78fbc024 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -58,7 +58,8 @@ public class GUIClosedException(message: String) : GUIException(message)
 /**
  * Exception thrown when the GUI is updating.
  */
-public class GUIUpdatedException(message: String) : GUIException(message)
+public class GUIUpdatedException(public val client: Client) :
+    GUIException("GUI updating for client ${client.playerUUID}")
 
 /**
  * Exception thrown when the GUI is closed for a specific client.
@@ -72,7 +73,6 @@ public class GUIClosedForClientException(public val client: Client) :
  * Only one inventory is created for all the viewers.
  * @property server Server.
  * @property manager Manager to register or unregister the GUI.
- * @property isClosed If true, the GUI is closed; otherwise it is open.
  */
 public abstract class GUI<T>(
     private val loadingAnimation: InventoryLoadingAnimation<T>? = null,
@@ -83,9 +83,6 @@ public abstract class GUI<T>(
 
     protected val manager: GUIManager by inject()
 
-    public var isClosed: Boolean = false
-        protected set
-
     protected var inventories: MutableMap<T, InventoryData> = HashMap(initialNumberInventories)
 
     protected val mutex: Mutex = Mutex()
@@ -112,8 +109,6 @@ public abstract class GUI<T>(
      * @return True if the GUI was opened, false otherwise.
      */
     public open suspend fun open(client: Client): Boolean {
-        requireOpen()
-
         val player = client.player
         if (player === null) {
             logger.warn { "Cannot open inventory for player ${client.playerUUID}: player is null" }
@@ -158,8 +153,9 @@ public abstract class GUI<T>(
      * @see [getItems]
      */
     public open suspend fun update(client: Client, interruptLoading: Boolean = false): Boolean {
+        val key = getKey(client)
+
         return mutex.withLock {
-            val key = getKey(client)
             val inventoryData = inventories[key] ?: return@withLock false
 
             // If the client doesn't have the GUI opened, do nothing.
@@ -172,7 +168,7 @@ public abstract class GUI<T>(
                     // If we want to interrupt the loading, we cancel the loading job.
                     // We need to wait for the job to be cancelled to avoid conflicts with the new loading animation.
                     inventoryData.job.apply {
-                        cancel(GUIUpdatedException("The GUI is updating"))
+                        cancel(GUIUpdatedException(client))
                         join()
                     }
                 }
@@ -219,6 +215,10 @@ public abstract class GUI<T>(
         // That's why we start with unconfined dispatcher.
         return fillScope(key).launch(Dispatchers.Unconfined) {
             val size = inventory.size
+            // Empty the inventory, there is no effect if the inventory is new
+            // But avoid conflicts with old items if the inventory is updated.
+            inventory.contents = arrayOfNulls(size)
+
             val inventoryFlowItems = getItems(key, size).cancellable()
 
             if (loadingAnimation == null) {
@@ -339,7 +339,6 @@ public abstract class GUI<T>(
      * The GUI will be removed from the listener and the [onClick] function will not be called anymore.
      */
     public open suspend fun close() {
-        isClosed = true
         unregister()
 
         mutex.withLock {
@@ -362,20 +361,13 @@ public abstract class GUI<T>(
      */
     public abstract suspend fun close(client: Client, closeInventory: Boolean = true): Boolean
 
-    /**
-     * Verify that the GUI is open.
-     * If the GUI is closed, throw an exception.
-     */
-    private fun requireOpen() {
-        if (isClosed) throw GUIClosedException("Cannot use a closed GUI")
-    }
-
     /**
      * Register the GUI to the listener.
+     * If the GUI is already registered, do nothing.
+     * If the GUI is closed, he will be opened again.
      * @return True if the GUI was registered, false otherwise.
      */
     public open suspend fun register(): Boolean {
-        requireOpen()
         return manager.add(this)
     }
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
index abf9ff48..4cf452b3 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
@@ -8,7 +8,6 @@ import com.github.rushyverse.api.extension.ItemStack
 import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
-import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.collections.shouldContainAll
 import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.shouldBe
@@ -71,10 +70,10 @@ abstract class AbstractGUITest : AbstractKoinTest() {
         }
 
         @Test
-        fun `should throw exception if GUI is closed`() = runTest {
+        fun `should register GUI if was closed`() = runTest {
             val gui = createNonFillGUI()
             gui.close()
-            shouldThrow<GUIClosedException> { gui.register() }
+            gui.register() shouldBe true
         }
     }
 
@@ -122,14 +121,15 @@ abstract class AbstractGUITest : AbstractKoinTest() {
     abstract inner class Open {
 
         @Test
-        fun `should throw exception if GUI is closed`() = runTest {
-            val gui = createNonFillGUI()
+        fun `should open if GUI was closed`() = runTest {
+            val type = InventoryType.FURNACE
+            val gui = createNonFillGUI(type)
             gui.close()
             val (player, client) = registerPlayer()
 
             val initialInventoryViewType = player.openInventory.type
-            shouldThrow<GUIClosedException> { gui.open(client) }
-            player.assertInventoryView(initialInventoryViewType)
+            gui.open(client) shouldBe true
+            player.assertInventoryView(type)
         }
 
         @Test
@@ -238,6 +238,80 @@ abstract class AbstractGUITest : AbstractKoinTest() {
 
     }
 
+    abstract inner class Update {
+
+        @Test
+        fun `should return false if the client is not viewing the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val (player, client) = registerPlayer()
+            val initialInventoryViewType = player.openInventory.type
+            gui.update(client) shouldBe false
+
+            gui.viewers().toList() shouldBe emptyList()
+            gui.contains(client) shouldBe false
+
+            player.assertInventoryView(initialInventoryViewType)
+        }
+
+        @Test
+        fun `should return false if the client is viewing the GUI with a loading inventory`() {
+            runBlocking {
+                val type = InventoryType.DISPENSER
+                val delay = 100.milliseconds
+                val gui = createFillGUI(emptyArray(), inventoryType = type, delay = delay)
+                val (player, client) = registerPlayer()
+
+                gui.open(client) shouldBe true
+
+                val guiInventory = player.openInventory.topInventory
+                gui.isInventoryLoading(guiInventory) shouldBe true
+
+                // We're waiting the half of the delay to be sure that the inventory is loading
+                delay(50.milliseconds)
+
+                gui.update(client) shouldBe false
+                player.assertInventoryView(type)
+                gui.viewers().toList() shouldContainExactlyInAnyOrder listOf(player)
+                gui.contains(client) shouldBe true
+
+                // if we interrupt the loading, the inventory should be loading from 0 to new delay
+                // but here, we didn't interrupt the loading, so the inventory should be loaded (50 + 80 = 130 > 100)
+                delay(80.milliseconds)
+
+                gui.isInventoryLoading(guiInventory) shouldBe false
+            }
+        }
+
+        @Test
+        fun `should return true if the client is viewing the GUI with a loaded inventory`() {
+            runBlocking {
+                val type = InventoryType.DISPENSER
+                val delay = 100.milliseconds
+                val gui = createFillGUI(emptyArray(), inventoryType = type, delay = delay)
+                val (player, client) = registerPlayer()
+
+                gui.open(client) shouldBe true
+                val guiInventory = player.openInventory.topInventory
+                gui.isInventoryLoading(guiInventory) shouldBe true
+
+                // We're waiting the half of the delay to be sure that the inventory is loading
+                delay(70.milliseconds)
+
+                gui.update(client, true) shouldBe true
+                player.assertInventoryView(type)
+                gui.viewers().toList() shouldContainExactlyInAnyOrder listOf(player)
+                gui.contains(client) shouldBe true
+
+                // if we interrupt the loading, the inventory should be loading from 0 to new delay
+                delay(70.milliseconds)
+                gui.isInventoryLoading(guiInventory) shouldBe true
+
+                delay(50.milliseconds)
+                gui.isInventoryLoading(guiInventory) shouldBe false
+            }
+        }
+    }
+
     abstract inner class Close {
 
         @Test
@@ -263,14 +337,6 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             }
         }
 
-        @Test
-        fun `should set isClosed to true`() = runTest {
-            val gui = createNonFillGUI()
-            gui.isClosed shouldBe false
-            gui.close()
-            gui.isClosed shouldBe true
-        }
-
         @Test
         fun `should unregister the GUI`() = runTest {
             val gui = createNonFillGUI()
@@ -279,27 +345,6 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             gui.close()
             guiManager.guis shouldContainAll listOf()
         }
-
-        @Test
-        fun `should not be able to open the GUI after closing it`() = runTest {
-            val gui = createNonFillGUI()
-            gui.register()
-            val (_, client) = registerPlayer()
-            gui.close()
-
-            shouldThrow<GUIClosedException> {
-                gui.open(client)
-            }
-        }
-
-        @Test
-        fun `should not be able to register the GUI after closing it`() = runTest {
-            val gui = createNonFillGUI()
-            gui.close()
-            shouldThrow<GUIClosedException> {
-                gui.register()
-            }
-        }
     }
 
     abstract inner class CloseForClient {
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
index 3e0fdce6..b6e6c731 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
@@ -131,6 +131,9 @@ class LocalePlayerGUITest : AbstractGUITest() {
 
     }
 
+    @Nested
+    inner class Update : AbstractGUITest.Update()
+
     @Nested
     inner class Close : AbstractGUITest.Close()
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
index 6f5877d4..071ecdd8 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
@@ -70,6 +70,9 @@ class PlayerGUITest : AbstractGUITest() {
         }
     }
 
+    @Nested
+    inner class Update : AbstractGUITest.Update()
+
     @Nested
     inner class Close : AbstractGUITest.Close()
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
index 0cd3c26f..fe87fb90 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -97,6 +97,9 @@ class SingleGUITest : AbstractGUITest() {
         }
     }
 
+    @Nested
+    inner class Update : AbstractGUITest.Update()
+
     @Nested
     inner class Close : AbstractGUITest.Close()
 

From 10598830bc8e75c26de488386ef9f295eb1ae329 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 16:15:33 +0100
Subject: [PATCH 26/50] chore: Move clear inventory out of Job

---
 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 78fbc024..7b88d78a 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -211,14 +211,14 @@ public abstract class GUI<T>(
      * @return The job that can be cancelled to stop the loading animation.
      */
     private suspend fun startLoadingInventory(key: T, inventory: Inventory): Job {
+        val size = inventory.size
+        // Empty the inventory, there is no effect if the inventory is new
+        // But avoid conflicts with old items if the inventory is updated.
+        inventory.contents = arrayOfNulls(size)
+
         // If no suspend operation is used in the flow, the fill will be done in the same thread & tick.
         // That's why we start with unconfined dispatcher.
         return fillScope(key).launch(Dispatchers.Unconfined) {
-            val size = inventory.size
-            // Empty the inventory, there is no effect if the inventory is new
-            // But avoid conflicts with old items if the inventory is updated.
-            inventory.contents = arrayOfNulls(size)
-
             val inventoryFlowItems = getItems(key, size).cancellable()
 
             if (loadingAnimation == null) {

From 9921afd5d1eced1e6ef0187460ed0a8533466a58 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 16:18:00 +0100
Subject: [PATCH 27/50] doc: Add missing property documentation

---
 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 7b88d78a..b12b832b 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -57,6 +57,7 @@ public class GUIClosedException(message: String) : GUIException(message)
 
 /**
  * Exception thrown when the GUI is updating.
+ * @property client Client for which the GUI is updating.
  */
 public class GUIUpdatedException(public val client: Client) :
     GUIException("GUI updating for client ${client.playerUUID}")

From 72cf8a37342584c67a29105ba4af993aaa1e6749 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 17:51:16 +0100
Subject: [PATCH 28/50] fix: Use UNIT as singleton value

---
 .../com/github/rushyverse/api/gui/SingleGUI.kt     | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
index 3ec24c71..af370b83 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
@@ -20,8 +20,8 @@ import org.bukkit.plugin.Plugin
  */
 public abstract class SingleGUI(
     protected val plugin: Plugin,
-    loadingAnimation: InventoryLoadingAnimation<Any>? = null
-) : GUI<Any>(
+    loadingAnimation: InventoryLoadingAnimation<Unit>? = null
+) : GUI<Unit>(
     loadingAnimation = loadingAnimation,
     initialNumberInventories = 1
 ) {
@@ -32,19 +32,19 @@ public abstract class SingleGUI(
          * This GUI is shared by all the players, so the key is the same for all of them.
          * That allows creating a unique inventory.
          */
-        private val KEY = Any()
+        private val KEY = Unit
     }
 
-    override suspend fun getKey(client: Client): Any {
+    override suspend fun getKey(client: Client) {
         return KEY
     }
 
-    override suspend fun fillScope(key: Any): CoroutineScope {
+    override suspend fun fillScope(key: Unit): CoroutineScope {
         val scope = plugin.scope
         return scope + SupervisorJob(scope.coroutineContext.job)
     }
 
-    override fun createInventory(key: Any): Inventory {
+    override fun createInventory(key: Unit): Inventory {
         return createInventory()
     }
 
@@ -60,7 +60,7 @@ public abstract class SingleGUI(
         } else false
     }
 
-    override fun getItems(key: Any, size: Int): Flow<ItemStackIndex> {
+    override fun getItems(key: Unit, size: Int): Flow<ItemStackIndex> {
         return getItems(size)
     }
 

From 84af5c971d3877a1d46a9a2b26173f45eb4fbbaf Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 17:51:46 +0100
Subject: [PATCH 29/50] fix: Avoid unnecessary operation if shift is 0

---
 .../load/ShiftInventoryLoadingAnimation.kt    | 24 ++++++++++++-------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
index 14f95f3e..453b3af3 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
@@ -3,6 +3,7 @@ package com.github.rushyverse.api.gui.load
 import java.util.*
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
@@ -27,16 +28,21 @@ public class ShiftInventoryLoadingAnimation<T>(
 ) : InventoryLoadingAnimation<T> {
 
     override suspend fun loading(key: T, inventory: Inventory) {
-        coroutineScope {
-            val size = inventory.size
-            val contents = arrayOfNulls<ItemStack>(size)
-            // Fill the inventory with the initial items.
-            // If the sequence is too short, it will be filled with null items.
-            // If the sequence is too long, the overflowing items will be ignored.
-            initialize(key).take(size).forEachIndexed { index, item ->
-                contents[index] = item
-            }
+        val size = inventory.size
+        val contents = arrayOfNulls<ItemStack>(size)
+        // Fill the inventory with the initial items.
+        // If the sequence is too short, it will be filled with null items.
+        // If the sequence is too long, the overflowing items will be ignored.
+        initialize(key).take(size).forEachIndexed { index, item ->
+            contents[index] = item
+        }
 
+        if(shift == 0) {
+            inventory.contents = contents
+            awaitCancellation()
+        }
+
+        coroutineScope {
             val contentList = contents.toMutableList()
             while (isActive) {
                 inventory.contents = contentList.toTypedArray()

From 134ccf66778efeb7b9f55d7d120f860211d21920 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 17:52:09 +0100
Subject: [PATCH 30/50] test: Begin test about shift inventory animation

---
 .../ShiftInventoryLoadingAnimationTest.kt     | 71 +++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
new file mode 100644
index 00000000..7554e431
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
@@ -0,0 +1,71 @@
+package com.github.rushyverse.api.gui.load
+
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockk
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+
+class ShiftInventoryLoadingAnimationTest {
+
+    private lateinit var inventory: Inventory
+
+    @BeforeTest
+    fun onBefore() {
+        inventory = mockk {
+            val contents = arrayOfNulls<ItemStack>(9 * 3)
+            every { size } returns contents.size
+            every { getContents() } returns contents
+            every { setContents(any()) } answers {
+                val items = firstArg<Array<ItemStack?>>()
+                items.forEachIndexed { index, itemStack ->
+                    contents[index] = itemStack
+                }
+        }
+            }
+    }
+
+    @Test
+    fun `should not change inventory if initialize is empty`() {
+        val delay = 10.milliseconds
+        val animation = ShiftInventoryLoadingAnimation<Unit>(
+            initialize = { emptySequence() },
+            shift = 1,
+            delay = delay
+        )
+
+        runBlocking {
+            val job = launch { animation.loading(Unit, inventory) }
+            delay(delay * 3)
+            job.cancelAndJoin()
+        }
+
+        inventory.contents shouldBe arrayOfNulls(inventory.size)
+    }
+
+    @Test
+    fun `should just initialize if shift is zero`() = runBlocking {
+        val delay = 10.milliseconds
+        val items = Array(inventory.size) { mockk<ItemStack>() }
+
+        val animation = ShiftInventoryLoadingAnimation<Unit>(
+            initialize = { items.asSequence() },
+            shift = 0,
+            delay = delay
+        )
+
+        val job = launch { animation.loading(Unit, inventory) }
+        delay(delay * 3)
+        job.cancelAndJoin()
+
+        inventory.contents.toList() shouldContainExactly items.toList()
+    }
+}

From 817348967aaad163216c02f399f85eb8c26a170f Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Tue, 19 Dec 2023 22:08:42 +0100
Subject: [PATCH 31/50] chore: Optimize and create new function for Client

---
 .../com/github/rushyverse/api/gui/GUI.kt      | 135 +++++++++++-------
 .../github/rushyverse/api/gui/GUIListener.kt  |   2 +-
 .../github/rushyverse/api/gui/LocaleGUI.kt    |   2 +-
 .../github/rushyverse/api/gui/PlayerGUI.kt    |   2 +-
 .../github/rushyverse/api/gui/SingleGUI.kt    |   2 +-
 .../rushyverse/api/gui/AbstractGUITest.kt     |  46 +++---
 .../rushyverse/api/gui/GUIListenerTest.kt     |   8 +-
 .../rushyverse/api/gui/LocalePlayerGUITest.kt |  24 ++--
 .../rushyverse/api/gui/PlayerGUITest.kt       |  24 ++--
 .../rushyverse/api/gui/SingleGUITest.kt       |  18 +--
 10 files changed, 150 insertions(+), 113 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index b12b832b..3d629acf 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -9,8 +9,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.cancellable
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.toCollection
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -48,19 +52,18 @@ private val logger = KotlinLogging.logger {}
 /**
  * Exception concerning the GUI.
  */
-public open class GUIException(message: String) : CancellationException(message)
+public open class GUIException(message: String? = null) : CancellationException(message)
 
 /**
  * Exception thrown when the GUI is closed.
  */
-public class GUIClosedException(message: String) : GUIException(message)
+public class GUIClosedException(message: String? = null) : GUIException(message)
 
 /**
  * Exception thrown when the GUI is updating.
  * @property client Client for which the GUI is updating.
  */
-public class GUIUpdatedException(public val client: Client) :
-    GUIException("GUI updating for client ${client.playerUUID}")
+public class GUIUpdatedException(public val client: Client?) : GUIException()
 
 /**
  * Exception thrown when the GUI is closed for a specific client.
@@ -109,9 +112,9 @@ public abstract class GUI<T>(
      * @param client Client to open the GUI for.
      * @return True if the GUI was opened, false otherwise.
      */
-    public open suspend fun open(client: Client): Boolean {
+    public open suspend fun openClient(client: Client): Boolean {
         val player = client.player
-        if (player === null) {
+        if (player == null) {
             logger.warn { "Cannot open inventory for player ${client.playerUUID}: player is null" }
             return false
         }
@@ -133,7 +136,7 @@ public abstract class GUI<T>(
             // If the opening was cancelled (null returned),
             // We need to unregister the client from the GUI
             // and maybe close the inventory if it is individual.
-            close(client, false)
+            closeClient(client, false)
             return false
         }
 
@@ -142,6 +145,7 @@ public abstract class GUI<T>(
 
     /**
      * Update the opened inventory for the client.
+     * If the opened inventory is shared with other players, the inventory will be updated for all the viewers.
      *
      * If the client has the GUI opened, the inventory will be updated.
      * If the client has another GUI opened, do nothing.
@@ -152,35 +156,69 @@ public abstract class GUI<T>(
      * to start a new loading animation.
      * @return True if the inventory was updated, false otherwise.
      * @see [getItems]
+     * @see [update]
      */
-    public open suspend fun update(client: Client, interruptLoading: Boolean = false): Boolean {
+    public open suspend fun updateClient(client: Client, interruptLoading: Boolean = false): Boolean {
         val key = getKey(client)
-
         return mutex.withLock {
-            val inventoryData = inventories[key] ?: return@withLock false
-
-            // If the client doesn't have the GUI opened, do nothing.
-            if (!unsafeContains(client)) return@withLock false
-
-            if (inventoryData.isLoading) {
-                // If we don't want to interrupt the loading and the inventory is loading, do nothing.
-                if (!interruptLoading) return@withLock false
-                else {
-                    // If we want to interrupt the loading, we cancel the loading job.
-                    // We need to wait for the job to be cancelled to avoid conflicts with the new loading animation.
-                    inventoryData.job.apply {
-                        cancel(GUIUpdatedException(client))
-                        join()
-                    }
+            if (!unsafeContains(client)) return false
+            unsafeUpdate(key, interruptLoading, client)
+        }
+    }
+
+    /**
+     * Update the inventory for the key.
+     * If the inventory is shared with several players, the inventory will be updated for all the viewers.
+     *
+     * If the inventory is not loaded, the inventory will be updated.
+     * If the inventory is loading, the inventory will be updated if [interruptLoading] is true.
+     *
+     * Call [getItems] to get the new items to fill the inventory.
+     * @param key Key to update the inventory for.
+     * @param interruptLoading If true and if the inventory is loading, the loading will be interrupted
+     * to start a new loading animation.
+     * @return True if the inventory was updated, false otherwise.
+     */
+    public suspend fun update(key: T, interruptLoading: Boolean = false): Boolean {
+        return mutex.withLock { unsafeUpdate(key, interruptLoading, null) }
+    }
+
+    /**
+     * This function is not thread-safe.
+     *
+     * Update the inventory for the key.
+     * If the inventory is shared with several players, the inventory will be updated for all the viewers.
+     *
+     * If the inventory is not loaded, the inventory will be updated.
+     * If the inventory is loading, the inventory will be updated if [interruptLoading] is true.
+     *
+     * Call [getItems] to get the new items to fill the inventory.
+     * @param key Key to update the inventory for.
+     * @param interruptLoading If true and if the inventory is loading, the loading will be interrupted
+     * to start a new loading animation.
+     * @return True if the inventory was updated, false otherwise.
+     */
+    private suspend fun unsafeUpdate(key: T, interruptLoading: Boolean = false, cause: Client? = null): Boolean {
+        val inventoryData = inventories[key] ?: return false
+
+        if (inventoryData.isLoading) {
+            // If we don't want to interrupt the loading and the inventory is loading, do nothing.
+            if (!interruptLoading) return false
+            else {
+                // If we want to interrupt the loading, we cancel the loading job.
+                // We need to wait for the job to be cancelled to avoid conflicts with the new loading animation.
+                inventoryData.job.apply {
+                    cancel(GUIUpdatedException(cause))
+                    join()
                 }
             }
-
-            val inventory = inventoryData.inventory
-            // Begin a new loading job and replace the old one.
-            val newLoadingJob = startLoadingInventory(key, inventory)
-            inventories[key] = InventoryData(inventory, newLoadingJob)
-            true
         }
+
+        val inventory = inventoryData.inventory
+        // Begin a new loading job and replace the old one.
+        val newLoadingJob = startLoadingInventory(key, inventory)
+        inventories[key] = InventoryData(inventory, newLoadingJob)
+        return true
     }
 
     /**
@@ -277,7 +315,7 @@ public abstract class GUI<T>(
      */
     public open suspend fun hasInventory(inventory: Inventory): Boolean {
         return mutex.withLock {
-            inventories.values.any { it.inventory == inventory }
+            inventories.values.any { it.inventory === inventory }
         }
     }
 
@@ -289,7 +327,7 @@ public abstract class GUI<T>(
      */
     public open suspend fun isInventoryLoading(inventory: Inventory): Boolean {
         return mutex.withLock {
-            inventories.values.firstOrNull { it.inventory == inventory }?.isLoading == true
+            inventories.values.firstOrNull { it.inventory === inventory }?.isLoading == true
         }
     }
 
@@ -298,9 +336,7 @@ public abstract class GUI<T>(
      * @return List of viewers.
      */
     public open suspend fun viewers(): Sequence<HumanEntity> {
-        return mutex.withLock {
-            unsafeViewers()
-        }
+        return mutex.withLock { unsafeViewers() }
     }
 
     /**
@@ -318,9 +354,7 @@ public abstract class GUI<T>(
      * @return True if the GUI contains the player, false otherwise.
      */
     public open suspend fun contains(client: Client): Boolean {
-        return mutex.withLock {
-            unsafeContains(client)
-        }
+        return mutex.withLock { unsafeContains(client) }
     }
 
     /**
@@ -331,7 +365,7 @@ public abstract class GUI<T>(
      */
     protected open fun unsafeContains(client: Client): Boolean {
         val player = client.player ?: return false
-        return unsafeViewers().any { it == player }
+        return unsafeViewers().any { it === player }
     }
 
     /**
@@ -343,15 +377,18 @@ public abstract class GUI<T>(
         unregister()
 
         mutex.withLock {
-            inventories.values.forEach {
-                it.job.apply {
-                    cancel(GUIClosedException("The GUI is closing"))
-                    join()
+            inventories.values.asFlow()
+                .onCompletion { inventories.clear() }
+                .onEach {
+                    val job = it.job
+                    job.cancel(GUIClosedException())
+                    job.join()
                 }
-                it.inventory.close()
-            }
-            inventories.clear()
-        }
+                .map { it.inventory }
+                .toCollection(ArrayList(inventories.size))
+            // Close the inventories out of the mutex
+            // to avoid slowing down the mutex with the events sent to the listeners.
+        }.forEach(Inventory::close)
     }
 
     /**
@@ -360,7 +397,7 @@ public abstract class GUI<T>(
      * @param closeInventory If true, the interface will be closed, otherwise it will be kept open.
      * @return True if the inventory was closed, false otherwise.
      */
-    public abstract suspend fun close(client: Client, closeInventory: Boolean = true): Boolean
+    public abstract suspend fun closeClient(client: Client, closeInventory: Boolean = true): Boolean
 
     /**
      * Register the GUI to the listener.
@@ -374,7 +411,7 @@ public abstract class GUI<T>(
 
     /**
      * Unregister the GUI from the listener.
-     * Should be called when the GUI is closed with [close].
+     * Should be called when the GUI is closed with [closeClient].
      * @return True if the GUI was unregistered, false otherwise.
      */
     protected open suspend fun unregister(): Boolean {
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
index 8053552f..276c56d0 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
@@ -121,7 +121,7 @@ public class GUIListener(private val plugin: Plugin) : Listener {
         val gui = client?.gui() ?: return
         // We don't close the inventory because it is closing due to event.
         // That avoids an infinite loop of events and consequently a stack overflow.
-        gui.close(client, false)
+        gui.closeClient(client, false)
     }
 
 }
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
index 4eaf1977..5e3d3f07 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/LocaleGUI.kt
@@ -37,7 +37,7 @@ public abstract class LocaleGUI(
         return scope + SupervisorJob(scope.coroutineContext.job)
     }
 
-    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+    override suspend fun closeClient(client: Client, closeInventory: Boolean): Boolean {
         return if (closeInventory && contains(client)) {
             client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
             true
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
index d5a096fc..24099333 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
@@ -51,7 +51,7 @@ public abstract class PlayerGUI(
         return inventories.containsKey(client)
     }
 
-    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+    override suspend fun closeClient(client: Client, closeInventory: Boolean): Boolean {
         val (inventory, job) = mutex.withLock { inventories.remove(client) } ?: return false
 
         job.cancel(GUIClosedForClientException(client))
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
index af370b83..1f45e38f 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
@@ -53,7 +53,7 @@ public abstract class SingleGUI(
      */
     protected abstract fun createInventory(): Inventory
 
-    override suspend fun close(client: Client, closeInventory: Boolean): Boolean {
+    override suspend fun closeClient(client: Client, closeInventory: Boolean): Boolean {
         return if (closeInventory && contains(client)) {
             client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)
             true
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
index 4cf452b3..9020840e 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
@@ -91,7 +91,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             val playerClients = List(5) { registerPlayer() }
 
             playerClients.forEach { (_, client) ->
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
             }
 
             gui.viewers().toList() shouldContainExactlyInAnyOrder playerClients.map { it.first }
@@ -112,13 +112,13 @@ abstract class AbstractGUITest : AbstractKoinTest() {
         fun `should return true if the client is viewing the GUI`() = runTest {
             val gui = createNonFillGUI()
             val (_, client) = registerPlayer()
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             gui.contains(client) shouldBe true
         }
 
     }
 
-    abstract inner class Open {
+    abstract inner class OpenClient {
 
         @Test
         fun `should open if GUI was closed`() = runTest {
@@ -128,7 +128,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             val (player, client) = registerPlayer()
 
             val initialInventoryViewType = player.openInventory.type
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             player.assertInventoryView(type)
         }
 
@@ -139,10 +139,10 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             gui.register()
             val (player, client) = registerPlayer()
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             player.assertInventoryView(type)
 
-            gui.open(client) shouldBe false
+            gui.openClient(client) shouldBe false
             player.assertInventoryView(type)
         }
 
@@ -154,7 +154,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             val initialInventoryViewType = player.openInventory.type
 
             player.health = 0.0
-            gui.open(client) shouldBe false
+            gui.openClient(client) shouldBe false
             player.assertInventoryView(initialInventoryViewType)
         }
 
@@ -174,7 +174,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
                 gui.register()
                 val (player, client) = registerPlayer()
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
 
                 val inventory = player.openInventory.topInventory
@@ -211,7 +211,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
                 gui.register()
                 val (player, client) = registerPlayer()
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
 
                 val inventory = player.openInventory.topInventory
@@ -238,14 +238,14 @@ abstract class AbstractGUITest : AbstractKoinTest() {
 
     }
 
-    abstract inner class Update {
+    abstract inner class UpdateClient {
 
         @Test
         fun `should return false if the client is not viewing the GUI`() = runTest {
             val gui = createNonFillGUI()
             val (player, client) = registerPlayer()
             val initialInventoryViewType = player.openInventory.type
-            gui.update(client) shouldBe false
+            gui.updateClient(client) shouldBe false
 
             gui.viewers().toList() shouldBe emptyList()
             gui.contains(client) shouldBe false
@@ -261,7 +261,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
                 val gui = createFillGUI(emptyArray(), inventoryType = type, delay = delay)
                 val (player, client) = registerPlayer()
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
 
                 val guiInventory = player.openInventory.topInventory
                 gui.isInventoryLoading(guiInventory) shouldBe true
@@ -269,7 +269,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
                 // We're waiting the half of the delay to be sure that the inventory is loading
                 delay(50.milliseconds)
 
-                gui.update(client) shouldBe false
+                gui.updateClient(client) shouldBe false
                 player.assertInventoryView(type)
                 gui.viewers().toList() shouldContainExactlyInAnyOrder listOf(player)
                 gui.contains(client) shouldBe true
@@ -290,14 +290,14 @@ abstract class AbstractGUITest : AbstractKoinTest() {
                 val gui = createFillGUI(emptyArray(), inventoryType = type, delay = delay)
                 val (player, client) = registerPlayer()
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 val guiInventory = player.openInventory.topInventory
                 gui.isInventoryLoading(guiInventory) shouldBe true
 
                 // We're waiting the half of the delay to be sure that the inventory is loading
                 delay(70.milliseconds)
 
-                gui.update(client, true) shouldBe true
+                gui.updateClient(client, true) shouldBe true
                 player.assertInventoryView(type)
                 gui.viewers().toList() shouldContainExactlyInAnyOrder listOf(player)
                 gui.contains(client) shouldBe true
@@ -325,7 +325,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
 
             playerClients.forEach { (player, client) ->
                 player.assertInventoryView(initialInventoryViewType)
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
                 client.gui() shouldBe gui
             }
@@ -347,7 +347,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
         }
     }
 
-    abstract inner class CloseForClient {
+    abstract inner class CloseClient {
 
         @Test
         fun `should return false if the client is not viewing the GUI`() = runTest {
@@ -357,7 +357,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             val initialInventoryViewType = player.openInventory.type
 
             player.assertInventoryView(initialInventoryViewType)
-            gui.close(client, true) shouldBe false
+            gui.closeClient(client, true) shouldBe false
             player.assertInventoryView(initialInventoryViewType)
         }
 
@@ -369,9 +369,9 @@ abstract class AbstractGUITest : AbstractKoinTest() {
 
             val initialInventoryViewType = player.openInventory.type
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             player.assertInventoryView(type)
-            gui.close(client, true) shouldBe true
+            gui.closeClient(client, true) shouldBe true
             player.assertInventoryView(initialInventoryViewType)
         }
 
@@ -383,13 +383,13 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             val (player2, client2) = registerPlayer()
             val initialInventoryViewType = player2.openInventory.type
 
-            gui.open(client) shouldBe true
-            gui.open(client2) shouldBe true
+            gui.openClient(client) shouldBe true
+            gui.openClient(client2) shouldBe true
 
             player.assertInventoryView(type)
             player2.assertInventoryView(type)
 
-            gui.close(client2, true) shouldBe true
+            gui.closeClient(client2, true) shouldBe true
             player.assertInventoryView(type)
             player2.assertInventoryView(initialInventoryViewType)
         }
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 6d9f6e27..2a86c9ed 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -192,7 +192,7 @@ class GUIListenerTest : AbstractKoinTest() {
             }
 
             callEvent(player)
-            coVerify(exactly = 0) { gui.close(client, any()) }
+            coVerify(exactly = 0) { gui.closeClient(client, any()) }
         }
 
         @Test
@@ -200,7 +200,7 @@ class GUIListenerTest : AbstractKoinTest() {
             val (player, client) = registerPlayer()
             val gui = registerGUI {
                 coEvery { contains(client) } returns true
-                coEvery { close(client, any()) } returns true
+                coEvery { closeClient(client, any()) } returns true
             }
 
             val gui2 = registerGUI {
@@ -209,8 +209,8 @@ class GUIListenerTest : AbstractKoinTest() {
 
             callEvent(player)
 
-            coVerify(exactly = 1) { gui.close(client, false) }
-            coVerify(exactly = 0) { gui2.close(client, any()) }
+            coVerify(exactly = 1) { gui.closeClient(client, false) }
+            coVerify(exactly = 0) { gui2.closeClient(client, any()) }
         }
 
         private suspend fun callEvent(player: Player) {
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
index b6e6c731..53294335 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
@@ -74,7 +74,7 @@ class LocalePlayerGUITest : AbstractGUITest() {
     inner class Contains : AbstractGUITest.Contains()
 
     @Nested
-    inner class Open : AbstractGUITest.Open() {
+    inner class OpenClient : AbstractGUITest.OpenClient() {
 
         @Test
         fun `should create a new inventory according to the language client`() = runTest {
@@ -85,8 +85,8 @@ class LocalePlayerGUITest : AbstractGUITest() {
             languageManager.set(player, SupportedLanguage.ENGLISH)
             languageManager.set(player2, SupportedLanguage.FRENCH)
 
-            gui.open(client) shouldBe true
-            gui.open(client2) shouldBe true
+            gui.openClient(client) shouldBe true
+            gui.openClient(client2) shouldBe true
 
             player.assertInventoryView(type)
             player2.assertInventoryView(type)
@@ -103,8 +103,8 @@ class LocalePlayerGUITest : AbstractGUITest() {
             languageManager.set(player, SupportedLanguage.FRENCH)
             languageManager.set(player2, SupportedLanguage.FRENCH)
 
-            gui.open(client) shouldBe true
-            gui.open(client2) shouldBe true
+            gui.openClient(client) shouldBe true
+            gui.openClient(client2) shouldBe true
 
             player.assertInventoryView(type)
             player2.assertInventoryView(type)
@@ -118,12 +118,12 @@ class LocalePlayerGUITest : AbstractGUITest() {
             val gui = createNonFillGUI(type)
             val (player, client) = registerPlayer()
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             val firstInventory = player.openInventory.topInventory
 
-            gui.close(client, true) shouldBe true
+            gui.closeClient(client, true) shouldBe true
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             player.openInventory.topInventory shouldBe firstInventory
 
             player.assertInventoryView(type)
@@ -132,13 +132,13 @@ class LocalePlayerGUITest : AbstractGUITest() {
     }
 
     @Nested
-    inner class Update : AbstractGUITest.Update()
+    inner class UpdateClient : AbstractGUITest.UpdateClient()
 
     @Nested
     inner class Close : AbstractGUITest.Close()
 
     @Nested
-    inner class CloseForClient : AbstractGUITest.CloseForClient() {
+    inner class CloseClient : AbstractGUITest.CloseClient() {
 
         @ParameterizedTest
         @ValueSource(booleans = [true, false])
@@ -151,14 +151,14 @@ class LocalePlayerGUITest : AbstractGUITest() {
 
                 val initialInventoryViewType = player.openInventory.type
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
 
                 val openInventory = player.openInventory
                 val inventory = openInventory.topInventory
                 gui.isInventoryLoading(inventory) shouldBe true
 
-                gui.close(client, closeInventory) shouldBe closeInventory
+                gui.closeClient(client, closeInventory) shouldBe closeInventory
                 gui.isInventoryLoading(inventory) shouldBe true
 
                 if (closeInventory) {
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
index 071ecdd8..358a8c79 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
@@ -34,7 +34,7 @@ class PlayerGUITest : AbstractGUITest() {
     inner class Contains : AbstractGUITest.Contains()
 
     @Nested
-    inner class Open : AbstractGUITest.Open() {
+    inner class OpenClient : AbstractGUITest.OpenClient() {
 
         @Test
         fun `should create a new inventory for the client`() = runTest {
@@ -43,8 +43,8 @@ class PlayerGUITest : AbstractGUITest() {
             val (player, client) = registerPlayer()
             val (player2, client2) = registerPlayer()
 
-            gui.open(client) shouldBe true
-            gui.open(client2) shouldBe true
+            gui.openClient(client) shouldBe true
+            gui.openClient(client2) shouldBe true
 
             player.assertInventoryView(type)
             player2.assertInventoryView(type)
@@ -58,12 +58,12 @@ class PlayerGUITest : AbstractGUITest() {
             val gui = createNonFillGUI(type)
             val (player, client) = registerPlayer()
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             val firstInventory = player.openInventory.topInventory
 
-            gui.close(client, true) shouldBe true
+            gui.closeClient(client, true) shouldBe true
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             player.openInventory.topInventory shouldNotBe firstInventory
 
             player.assertInventoryView(type)
@@ -71,13 +71,13 @@ class PlayerGUITest : AbstractGUITest() {
     }
 
     @Nested
-    inner class Update : AbstractGUITest.Update()
+    inner class UpdateClient : AbstractGUITest.UpdateClient()
 
     @Nested
     inner class Close : AbstractGUITest.Close()
 
     @Nested
-    inner class CloseForClient : AbstractGUITest.CloseForClient() {
+    inner class CloseClient : AbstractGUITest.CloseClient() {
 
         @ParameterizedTest
         @ValueSource(booleans = [true, false])
@@ -90,14 +90,14 @@ class PlayerGUITest : AbstractGUITest() {
 
                 val initialInventoryViewType = player.openInventory.type
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
 
                 val openInventory = player.openInventory
                 val inventory = openInventory.topInventory
                 gui.isInventoryLoading(inventory) shouldBe true
 
-                gui.close(client, closeInventory) shouldBe true
+                gui.closeClient(client, closeInventory) shouldBe true
                 gui.isInventoryLoading(inventory) shouldBe false
 
                 if (closeInventory) {
@@ -115,10 +115,10 @@ class PlayerGUITest : AbstractGUITest() {
                 val gui = NonFillGUI(serverMock, type = type)
                 val (player, client) = registerPlayer()
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
 
-                gui.close(client, false) shouldBe true
+                gui.closeClient(client, false) shouldBe true
                 player.assertInventoryView(type)
 
                 gui.contains(client) shouldBe false
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
index fe87fb90..7e27fc3b 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -62,7 +62,7 @@ class SingleGUITest : AbstractGUITest() {
     inner class Contains : AbstractGUITest.Contains()
 
     @Nested
-    inner class Open : AbstractGUITest.Open() {
+    inner class OpenClient : AbstractGUITest.OpenClient() {
 
         @Test
         fun `should use the same inventory for all clients`() = runTest {
@@ -70,7 +70,7 @@ class SingleGUITest : AbstractGUITest() {
             val gui = createNonFillGUI(type)
             val inventories = List(5) {
                 val (player, client) = registerPlayer()
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
 
                 player.openInventory.topInventory
@@ -85,12 +85,12 @@ class SingleGUITest : AbstractGUITest() {
             val gui = createNonFillGUI(type)
             val (player, client) = registerPlayer()
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             val firstInventory = player.openInventory.topInventory
 
-            gui.close(client, true) shouldBe true
+            gui.closeClient(client, true) shouldBe true
 
-            gui.open(client) shouldBe true
+            gui.openClient(client) shouldBe true
             player.openInventory.topInventory shouldBe firstInventory
 
             player.assertInventoryView(type)
@@ -98,13 +98,13 @@ class SingleGUITest : AbstractGUITest() {
     }
 
     @Nested
-    inner class Update : AbstractGUITest.Update()
+    inner class UpdateClient : AbstractGUITest.UpdateClient()
 
     @Nested
     inner class Close : AbstractGUITest.Close()
 
     @Nested
-    inner class CloseForClient : AbstractGUITest.CloseForClient() {
+    inner class CloseClient : AbstractGUITest.CloseClient() {
 
         @ParameterizedTest
         @ValueSource(booleans = [true, false])
@@ -117,14 +117,14 @@ class SingleGUITest : AbstractGUITest() {
 
                 val initialInventoryViewType = player.openInventory.type
 
-                gui.open(client) shouldBe true
+                gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
 
                 val openInventory = player.openInventory
                 val inventory = openInventory.topInventory
                 gui.isInventoryLoading(inventory) shouldBe true
 
-                gui.close(client, closeInventory) shouldBe closeInventory
+                gui.closeClient(client, closeInventory) shouldBe closeInventory
                 gui.isInventoryLoading(inventory) shouldBe true
 
                 if (closeInventory) {

From b88592323e00e0075c0d4077c35d50a49db8dc3a Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 00:12:07 +0100
Subject: [PATCH 32/50] test: Add tests about inventory management

---
 .../com/github/rushyverse/api/gui/GUI.kt      |  2 +-
 .../github/rushyverse/api/gui/PlayerGUI.kt    |  4 +
 .../rushyverse/api/gui/AbstractGUITest.kt     | 96 ++++++++++++++++++-
 .../rushyverse/api/gui/LocalePlayerGUITest.kt |  6 ++
 .../rushyverse/api/gui/PlayerGUITest.kt       |  6 ++
 .../rushyverse/api/gui/SingleGUITest.kt       |  6 ++
 6 files changed, 117 insertions(+), 3 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 3d629acf..6a389807 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -179,7 +179,7 @@ public abstract class GUI<T>(
      * to start a new loading animation.
      * @return True if the inventory was updated, false otherwise.
      */
-    public suspend fun update(key: T, interruptLoading: Boolean = false): Boolean {
+    public open suspend fun update(key: T, interruptLoading: Boolean = false): Boolean {
         return mutex.withLock { unsafeUpdate(key, interruptLoading, null) }
     }
 
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
index 24099333..116a43db 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
@@ -26,6 +26,10 @@ public abstract class PlayerGUI(
         return key + SupervisorJob(key.coroutineContext.job)
     }
 
+    override suspend fun update(key: Client, interruptLoading: Boolean): Boolean {
+        return super.updateClient(key, interruptLoading)
+    }
+
     /**
      * Create the inventory for the client.
      * Will translate the title and fill the inventory.
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
index 9020840e..66655ded 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
@@ -1,6 +1,7 @@
 package com.github.rushyverse.api.gui
 
 import be.seeseemelk.mockbukkit.MockBukkit
+import be.seeseemelk.mockbukkit.MockPlugin
 import be.seeseemelk.mockbukkit.ServerMock
 import be.seeseemelk.mockbukkit.entity.PlayerMock
 import com.github.rushyverse.api.AbstractKoinTest
@@ -12,6 +13,11 @@ import io.kotest.matchers.collections.shouldContainAll
 import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.spyk
+import java.net.InetSocketAddress
+import java.util.*
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
@@ -24,6 +30,7 @@ import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
 import org.bukkit.Material
 import org.bukkit.event.inventory.InventoryType
+import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 
 abstract class AbstractGUITest : AbstractKoinTest() {
@@ -31,6 +38,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
     protected lateinit var guiManager: GUIManager
     protected lateinit var clientManager: ClientManager
     protected lateinit var serverMock: ServerMock
+    protected lateinit var pluginMock: MockPlugin
 
     @BeforeTest
     override fun onBefore() {
@@ -44,6 +52,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
         }
 
         serverMock = MockBukkit.mock()
+        pluginMock = MockBukkit.createMockPlugin()
     }
 
     @AfterTest
@@ -158,6 +167,24 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             player.assertInventoryView(initialInventoryViewType)
         }
 
+        @Test
+        fun `should do nothing if the player open inventory is cancelled`() = runTest {
+            val gui = createNonFillGUI()
+
+            val basePlayer = serverMock.addPlayer()
+            val uuid = UUID.randomUUID()
+            val player = spyk(basePlayer) {
+                every { uniqueId } returns uuid
+                every { address } returns InetSocketAddress(0)
+                every { openInventory(any<Inventory>()) } returns null
+            }
+            val (_, client) = registerPlayer(player)
+
+            gui.openClient(client) shouldBe false
+            gui.contains(client) shouldBe false
+            gui.viewers().toList() shouldBe emptyList()
+        }
+
         @Test
         fun `should fill the inventory in the same thread if no suspend operation`() {
 
@@ -236,6 +263,11 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             }
         }
 
+        @Test
+        fun `should use loading animation`() {
+            TODO()
+        }
+
     }
 
     abstract inner class UpdateClient {
@@ -312,6 +344,66 @@ abstract class AbstractGUITest : AbstractKoinTest() {
         }
     }
 
+    abstract inner class HasInventory {
+
+        @Test
+        fun `should return false if the inventory doesn't come from GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val (_, client) = registerPlayer()
+            gui.openClient(client) shouldBe true
+            gui.hasInventory(mockk()) shouldBe false
+        }
+
+        @Test
+        fun `should return true if the client is viewing the GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val (player, client) = registerPlayer()
+            gui.openClient(client) shouldBe true
+
+            val inventory = player.openInventory.topInventory
+            gui.hasInventory(inventory) shouldBe true
+        }
+
+    }
+
+    abstract inner class IsInventoryLoading {
+
+        @Test
+        fun `should return false if the inventory doesn't come from GUI`() = runTest {
+            val gui = createNonFillGUI()
+            val (_, client) = registerPlayer()
+            gui.openClient(client) shouldBe true
+            gui.isInventoryLoading(mockk()) shouldBe false
+        }
+
+        @Test
+        fun `should return false if the inventory is not loading`() = runTest {
+            val gui = createNonFillGUI()
+            val (player, client) = registerPlayer()
+            gui.openClient(client) shouldBe true
+
+            val inventory = player.openInventory.topInventory
+            gui.isInventoryLoading(inventory) shouldBe false
+        }
+
+        @Test
+        fun `should return true if the inventory is loading`() {
+            runBlocking {
+                val delay = 50.milliseconds
+                val gui = createFillGUI(emptyArray(), delay = delay)
+                val (player, client) = registerPlayer()
+                gui.openClient(client) shouldBe true
+
+                val inventory = player.openInventory.topInventory
+                gui.isInventoryLoading(inventory) shouldBe true
+
+                delay(delay * 2)
+
+                gui.isInventoryLoading(inventory) shouldBe false
+            }
+        }
+    }
+
     abstract inner class Close {
 
         @Test
@@ -409,8 +501,8 @@ abstract class AbstractGUITest : AbstractKoinTest() {
 
     abstract fun getFillThreadAfterSuspend(gui: GUI<*>): Thread?
 
-    protected suspend fun registerPlayer(): Pair<PlayerMock, Client> {
-        val player = serverMock.addPlayer()
+    protected suspend fun registerPlayer(playerMock: PlayerMock? = null): Pair<PlayerMock, Client> {
+        val player = playerMock?.also { serverMock.addPlayer(it) } ?: serverMock.addPlayer()
         val client = Client(player.uniqueId, CoroutineScope(EmptyCoroutineContext))
         clientManager.put(player, client)
         return player to client
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
index 53294335..448ba205 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
@@ -134,6 +134,12 @@ class LocalePlayerGUITest : AbstractGUITest() {
     @Nested
     inner class UpdateClient : AbstractGUITest.UpdateClient()
 
+    @Nested
+    inner class HasInventory : AbstractGUITest.HasInventory()
+
+    @Nested
+    inner class IsInventoryLoading : AbstractGUITest.IsInventoryLoading()
+
     @Nested
     inner class Close : AbstractGUITest.Close()
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
index 358a8c79..629a1e46 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
@@ -73,6 +73,12 @@ class PlayerGUITest : AbstractGUITest() {
     @Nested
     inner class UpdateClient : AbstractGUITest.UpdateClient()
 
+    @Nested
+    inner class HasInventory : AbstractGUITest.HasInventory()
+
+    @Nested
+    inner class IsInventoryLoading : AbstractGUITest.IsInventoryLoading()
+
     @Nested
     inner class Close : AbstractGUITest.Close()
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
index 7e27fc3b..610ad7ad 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -100,6 +100,12 @@ class SingleGUITest : AbstractGUITest() {
     @Nested
     inner class UpdateClient : AbstractGUITest.UpdateClient()
 
+    @Nested
+    inner class HasInventory : AbstractGUITest.HasInventory()
+
+    @Nested
+    inner class IsInventoryLoading : AbstractGUITest.IsInventoryLoading()
+
     @Nested
     inner class Close : AbstractGUITest.Close()
 

From 55f8c45aac78925e538802b53cfaf9184a802149 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 09:56:45 +0100
Subject: [PATCH 33/50] fix: Add dedicated function to simplify management

---
 .../github/rushyverse/api/gui/PlayerGUI.kt    | 15 ++++++++-------
 .../github/rushyverse/api/gui/SingleGUI.kt    | 19 +++++++++++++++++--
 2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
index 116a43db..c94ca7ae 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
@@ -26,8 +26,14 @@ public abstract class PlayerGUI(
         return key + SupervisorJob(key.coroutineContext.job)
     }
 
-    override suspend fun update(key: Client, interruptLoading: Boolean): Boolean {
-        return super.updateClient(key, interruptLoading)
+    override suspend fun updateClient(client: Client, interruptLoading: Boolean): Boolean {
+        // Little optimization to avoid checking if the client is contained in map's values.
+        return super.update(client, interruptLoading)
+    }
+
+    override fun unsafeContains(client: Client): Boolean {
+        // Little optimization to avoid checking if the client is contained in map's values.
+        return inventories.containsKey(client)
     }
 
     /**
@@ -50,11 +56,6 @@ public abstract class PlayerGUI(
      */
     protected abstract fun createInventory(owner: InventoryHolder, client: Client): Inventory
 
-    override fun unsafeContains(client: Client): Boolean {
-        // Little optimization to avoid searching in the map from values.
-        return inventories.containsKey(client)
-    }
-
     override suspend fun closeClient(client: Client, closeInventory: Boolean): Boolean {
         val (inventory, job) = mutex.withLock { inventories.remove(client) } ?: return false
 
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
index 1f45e38f..ba9a2817 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
@@ -32,7 +32,7 @@ public abstract class SingleGUI(
          * This GUI is shared by all the players, so the key is the same for all of them.
          * That allows creating a unique inventory.
          */
-        private val KEY = Unit
+        private val KEY: Unit get() = Unit
     }
 
     override suspend fun getKey(client: Client) {
@@ -49,10 +49,25 @@ public abstract class SingleGUI(
     }
 
     /**
-     * @see createInventory(key)
+     * Create the inventory.
+     * @return New created inventory.
      */
     protected abstract fun createInventory(): Inventory
 
+    /**
+     * Update the inventory.
+     * If the inventory is not loaded, the inventory will be updated.
+     * If the inventory is loading, the inventory will be updated if [interruptLoading] is true.
+     *
+     * Call [getItems] to get the new items to fill the inventory.
+     * @param interruptLoading If true and if the inventory is loading, the loading will be interrupted
+     * to start a new loading animation.
+     * @return True if the inventory was updated, false otherwise.
+     */
+    public suspend fun update(interruptLoading: Boolean = false): Boolean {
+        return super.update(KEY, interruptLoading)
+    }
+
     override suspend fun closeClient(client: Client, closeInventory: Boolean): Boolean {
         return if (closeInventory && contains(client)) {
             client.player?.closeInventory(InventoryCloseEvent.Reason.PLUGIN)

From 5e5305deafa113f244cb45c6f760b3dc403211c1 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 11:12:00 +0100
Subject: [PATCH 34/50] fix: Keep loading state if  animation end

---
 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 6a389807..3b4db03a 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -7,6 +7,7 @@ import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.asFlow
@@ -264,7 +265,12 @@ public abstract class GUI<T>(
                 // Will fill the inventory bit by bit.
                 inventoryFlowItems.collect { (index, item) -> inventory.setItem(index, item) }
             } else {
-                val loadingAnimationJob = launch { loadingAnimation.loading(key, inventory) }
+                val loadingAnimationJob = launch {
+                    loadingAnimation.loading(key, inventory)
+                    // If the loading function is finished, the "loading" state must be continued
+                    // until the flow is finished.
+                    awaitCancellation()
+                }
 
                 // To avoid conflicts with the loading animation,
                 // we need to store the items in a temporary inventory

From a54555d82bfc5dcb0089493f7e2f1ea0de843d32 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 11:12:54 +0100
Subject: [PATCH 35/50] fix: Avoid useless shift for animation

---
 .../api/gui/load/ShiftInventoryLoadingAnimation.kt   | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
index 453b3af3..726b67a9 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
@@ -23,10 +23,14 @@ import org.bukkit.inventory.ItemStack
  */
 public class ShiftInventoryLoadingAnimation<T>(
     private val initialize: (T) -> Sequence<ItemStack>,
-    private val shift: Int = 1,
-    private val delay: Duration = 100.milliseconds,
+    public val shift: Int = 1,
+    public val delay: Duration = 100.milliseconds,
 ) : InventoryLoadingAnimation<T> {
 
+    init {
+        require(delay > Duration.ZERO) { "Delay must be positive" }
+    }
+
     override suspend fun loading(key: T, inventory: Inventory) {
         val size = inventory.size
         val contents = arrayOfNulls<ItemStack>(size)
@@ -37,9 +41,9 @@ public class ShiftInventoryLoadingAnimation<T>(
             contents[index] = item
         }
 
-        if(shift == 0) {
+        if(shift == 0 || shift == inventory.size) {
             inventory.contents = contents
-            awaitCancellation()
+            return
         }
 
         coroutineScope {

From 13589119e992c3ccd62a943689cadec31c2d52cf Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 13:12:11 +0100
Subject: [PATCH 36/50] test: Add tests about fill animation

---
 .../load/ShiftInventoryLoadingAnimation.kt    |  1 -
 .../rushyverse/api/gui/AbstractGUITest.kt     | 95 ++++++++++++++++++-
 .../rushyverse/api/gui/LocalePlayerGUITest.kt | 27 +++++-
 .../rushyverse/api/gui/PlayerGUITest.kt       | 27 +++++-
 .../rushyverse/api/gui/SingleGUITest.kt       | 27 +++++-
 .../ShiftInventoryLoadingAnimationTest.kt     |  2 +-
 6 files changed, 165 insertions(+), 14 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
index 726b67a9..513eda73 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimation.kt
@@ -3,7 +3,6 @@ package com.github.rushyverse.api.gui.load
 import java.util.*
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
-import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
index 66655ded..ce2606c5 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
@@ -6,6 +6,7 @@ import be.seeseemelk.mockbukkit.ServerMock
 import be.seeseemelk.mockbukkit.entity.PlayerMock
 import com.github.rushyverse.api.AbstractKoinTest
 import com.github.rushyverse.api.extension.ItemStack
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
@@ -24,6 +25,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
@@ -127,7 +129,7 @@ abstract class AbstractGUITest : AbstractKoinTest() {
 
     }
 
-    abstract inner class OpenClient {
+    abstract inner class OpenClient<T> {
 
         @Test
         fun `should open if GUI was closed`() = runTest {
@@ -136,7 +138,6 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             gui.close()
             val (player, client) = registerPlayer()
 
-            val initialInventoryViewType = player.openInventory.type
             gui.openClient(client) shouldBe true
             player.assertInventoryView(type)
         }
@@ -265,9 +266,97 @@ abstract class AbstractGUITest : AbstractKoinTest() {
 
         @Test
         fun `should use loading animation`() {
-            TODO()
+            val loadingItem = ItemStack { type = Material.BARRIER }
+            val item1 = ItemStack { type = Material.APPLE }
+            val item2 = ItemStack { type = Material.BEEF }
+
+            val animation = createAnimation(loadingItem)
+
+            val gui = createDelayGUI(
+                item1,
+                item2,
+                delay = 1.seconds,
+                inventoryType = InventoryType.CHEST,
+                loadingAnimation = animation
+            )
+
+            runBlocking {
+                val (player, client) = registerPlayer()
+                gui.openClient(client) shouldBe true
+                val guiInventory = player.openInventory.topInventory
+
+                // Animation should be called so the real items should not be in the inventory
+                val firstContents = guiInventory.contents
+                firstContents.getOrNull(0) shouldBe loadingItem
+                firstContents.getOrNull(1) shouldBe null
+                gui.isInventoryLoading(guiInventory) shouldBe true
+
+                delay(100.milliseconds)
+
+                // Until all items are emitted, the inventory should not be filled
+                val secondContents = guiInventory.contents
+                secondContents.getOrNull(0) shouldBe loadingItem
+                secondContents.getOrNull(1) shouldBe null
+                gui.isInventoryLoading(guiInventory) shouldBe true
+
+                delay(1.seconds)
+
+                // After all items are emitted, the inventory should be filled
+                val thirdContents = guiInventory.contents
+                thirdContents.getOrNull(0) shouldBe item1
+                thirdContents.getOrNull(1) shouldBe item2
+                gui.isInventoryLoading(guiInventory) shouldBe false
+            }
+        }
+
+        @Test
+        fun `should set bit by bit if no loading animation`() {
+            val item1 = ItemStack { type = Material.APPLE }
+            val item2 = ItemStack { type = Material.BEEF }
+
+            val gui = createDelayGUI(
+                item1,
+                item2,
+                delay = 1.seconds,
+                inventoryType = InventoryType.CHEST,
+                loadingAnimation = null
+            )
+
+            runBlocking {
+                val (player, client) = registerPlayer()
+                gui.openClient(client) shouldBe true
+                delay(100.milliseconds)
+                val guiInventory = player.openInventory.topInventory
+
+                // Animation should be called so the real items should not be in the inventory
+                val firstContents = guiInventory.contents
+                firstContents.getOrNull(0) shouldBe item1
+                firstContents.getOrNull(1) shouldBe null
+                gui.isInventoryLoading(guiInventory) shouldBe true
+
+                delay(1.seconds)
+
+                // After all items are emitted, the inventory should be filled
+                val secondContents = guiInventory.contents
+                secondContents.getOrNull(0) shouldBe item1
+                secondContents.getOrNull(1) shouldBe item2
+                gui.isInventoryLoading(guiInventory) shouldBe false
+            }
         }
 
+        private fun createAnimation(loadingItem: ItemStack) =
+            InventoryLoadingAnimation<T> { _, inventory ->
+                inventory.setItem(0, loadingItem)
+            }
+
+        protected abstract fun createDelayGUI(
+            item1: ItemStack,
+            item2: ItemStack,
+            delay: Duration,
+            inventoryType: InventoryType,
+            loadingAnimation: InventoryLoadingAnimation<T>?
+        ): GUI<T>
+
     }
 
     abstract inner class UpdateClient {
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
index 448ba205..940d583e 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
@@ -1,6 +1,7 @@
 package com.github.rushyverse.api.gui
 
 import be.seeseemelk.mockbukkit.ServerMock
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.language.LanguageManager
 import com.github.rushyverse.api.translation.SupportedLanguage
@@ -15,6 +16,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
@@ -74,7 +76,7 @@ class LocalePlayerGUITest : AbstractGUITest() {
     inner class Contains : AbstractGUITest.Contains()
 
     @Nested
-    inner class OpenClient : AbstractGUITest.OpenClient() {
+    inner class OpenClient : AbstractGUITest.OpenClient<Locale>() {
 
         @Test
         fun `should create a new inventory according to the language client`() = runTest {
@@ -129,6 +131,24 @@ class LocalePlayerGUITest : AbstractGUITest() {
             player.assertInventoryView(type)
         }
 
+        override fun createDelayGUI(
+            item1: ItemStack,
+            item2: ItemStack,
+            delay: Duration,
+            inventoryType: InventoryType,
+            loadingAnimation: InventoryLoadingAnimation<Locale>?
+        ): GUI<Locale> {
+            return object : AbstractLocaleGUITest(plugin, serverMock, InventoryType.CHEST, loadingAnimation) {
+                override fun getItems(key: Locale, size: Int): Flow<ItemStackIndex> {
+                    return flow {
+                        emit(0 to item1)
+                        delay(1.seconds)
+                        emit(1 to item2)
+                    }
+                }
+            }
+        }
+
     }
 
     @Nested
@@ -182,8 +202,9 @@ class LocalePlayerGUITest : AbstractGUITest() {
 private abstract class AbstractLocaleGUITest(
     plugin: Plugin,
     val serverMock: ServerMock,
-    val type: InventoryType = InventoryType.HOPPER
-) : LocaleGUI(plugin) {
+    val type: InventoryType = InventoryType.HOPPER,
+    animation: InventoryLoadingAnimation<Locale>? = null
+) : LocaleGUI(plugin, animation) {
 
     override fun createInventory(key: Locale): Inventory {
         return serverMock.createInventory(null, type)
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
index 629a1e46..5213edae 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
@@ -1,12 +1,14 @@
 package com.github.rushyverse.api.gui
 
 import be.seeseemelk.mockbukkit.ServerMock
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
 import kotlin.test.Test
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.emptyFlow
@@ -34,7 +36,7 @@ class PlayerGUITest : AbstractGUITest() {
     inner class Contains : AbstractGUITest.Contains()
 
     @Nested
-    inner class OpenClient : AbstractGUITest.OpenClient() {
+    inner class OpenClient : AbstractGUITest.OpenClient<Client>() {
 
         @Test
         fun `should create a new inventory for the client`() = runTest {
@@ -68,6 +70,24 @@ class PlayerGUITest : AbstractGUITest() {
 
             player.assertInventoryView(type)
         }
+
+        override fun createDelayGUI(
+            item1: ItemStack,
+            item2: ItemStack,
+            delay: Duration,
+            inventoryType: InventoryType,
+            loadingAnimation: InventoryLoadingAnimation<Client>?
+        ): GUI<Client> {
+            return object : AbstractPlayerGUITest(serverMock, InventoryType.CHEST, loadingAnimation) {
+                override fun getItems(key: Client, size: Int): Flow<ItemStackIndex> {
+                    return flow {
+                        emit(0 to item1)
+                        delay(1.seconds)
+                        emit(1 to item2)
+                    }
+                }
+            }
+        }
     }
 
     @Nested
@@ -150,8 +170,9 @@ class PlayerGUITest : AbstractGUITest() {
 
 private abstract class AbstractPlayerGUITest(
     val serverMock: ServerMock,
-    val type: InventoryType
-) : PlayerGUI() {
+    val type: InventoryType,
+    loadingAnimation: InventoryLoadingAnimation<Client>? = null
+) : PlayerGUI(loadingAnimation) {
 
     override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
         return serverMock.createInventory(owner, type)
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
index 610ad7ad..edee2ab9 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -1,6 +1,7 @@
 package com.github.rushyverse.api.gui
 
 import be.seeseemelk.mockbukkit.ServerMock
+import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
 import com.github.shynixn.mccoroutine.bukkit.scope
 import io.kotest.matchers.shouldBe
@@ -11,6 +12,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
@@ -62,7 +64,7 @@ class SingleGUITest : AbstractGUITest() {
     inner class Contains : AbstractGUITest.Contains()
 
     @Nested
-    inner class OpenClient : AbstractGUITest.OpenClient() {
+    inner class OpenClient : AbstractGUITest.OpenClient<Unit>() {
 
         @Test
         fun `should use the same inventory for all clients`() = runTest {
@@ -95,6 +97,24 @@ class SingleGUITest : AbstractGUITest() {
 
             player.assertInventoryView(type)
         }
+
+        override fun createDelayGUI(
+            item1: ItemStack,
+            item2: ItemStack,
+            delay: Duration,
+            inventoryType: InventoryType,
+            loadingAnimation: InventoryLoadingAnimation<Unit>?
+        ): GUI<Unit> {
+            return object : AbstractSingleGUITest(plugin, serverMock, InventoryType.CHEST, loadingAnimation) {
+                override fun getItems(size: Int): Flow<ItemStackIndex> {
+                    return flow {
+                        emit(0 to item1)
+                        delay(1.seconds)
+                        emit(1 to item2)
+                    }
+                }
+            }
+        }
     }
 
     @Nested
@@ -149,8 +169,9 @@ class SingleGUITest : AbstractGUITest() {
 private abstract class AbstractSingleGUITest(
     plugin: Plugin,
     val serverMock: ServerMock,
-    val type: InventoryType
-) : SingleGUI(plugin) {
+    val type: InventoryType,
+    animation: InventoryLoadingAnimation<Unit>? = null
+) : SingleGUI(plugin, animation) {
 
     override fun createInventory(): Inventory {
         return serverMock.createInventory(null, type)
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
index 7554e431..6e03eb7b 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
@@ -29,8 +29,8 @@ class ShiftInventoryLoadingAnimationTest {
                 items.forEachIndexed { index, itemStack ->
                     contents[index] = itemStack
                 }
-        }
             }
+        }
     }
 
     @Test

From 8f530e79b309847fec21df530a1a464244fb1b2f Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 13:33:24 +0100
Subject: [PATCH 37/50] test: Add verification for close GUI

---
 .../com/github/rushyverse/api/gui/AbstractGUITest.kt      | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
index ce2606c5..6d3c672a 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/AbstractGUITest.kt
@@ -504,14 +504,20 @@ abstract class AbstractGUITest : AbstractKoinTest() {
             val playerClients = List(5) { registerPlayer() }
             val initialInventoryViewType = playerClients.first().first.openInventory.type
 
-            playerClients.forEach { (player, client) ->
+            val inventories = playerClients.map { (player, client) ->
                 player.assertInventoryView(initialInventoryViewType)
                 gui.openClient(client) shouldBe true
                 player.assertInventoryView(type)
                 client.gui() shouldBe gui
+                player.openInventory.topInventory
             }
 
             gui.close()
+
+            inventories.forEach { inventory ->
+                gui.hasInventory(inventory) shouldBe false
+            }
+
             playerClients.forEach { (player, client) ->
                 player.assertInventoryView(initialInventoryViewType)
                 client.gui() shouldBe null

From 58e4ec914206e976aea8e9768723e1566c69df4c Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 13:38:59 +0100
Subject: [PATCH 38/50] test: Add test about update for single GUI

---
 .../rushyverse/api/gui/SingleGUITest.kt       | 23 +++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
index edee2ab9..e674c8c8 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -5,8 +5,11 @@ import com.github.rushyverse.api.gui.load.InventoryLoadingAnimation
 import com.github.rushyverse.api.player.Client
 import com.github.shynixn.mccoroutine.bukkit.scope
 import io.kotest.matchers.shouldBe
+import io.mockk.coEvery
+import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockkStatic
+import io.mockk.spyk
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -38,11 +41,11 @@ class SingleGUITest : AbstractGUITest() {
         every { plugin.scope } returns CoroutineScope(EmptyCoroutineContext)
     }
 
-    override fun createNonFillGUI(inventoryType: InventoryType): GUI<*> {
+    override fun createNonFillGUI(inventoryType: InventoryType): SingleGUI {
         return SingleNonFillGUI(plugin, serverMock, inventoryType)
     }
 
-    override fun createFillGUI(items: Array<ItemStack>, inventoryType: InventoryType, delay: Duration?): GUI<*> {
+    override fun createFillGUI(items: Array<ItemStack>, inventoryType: InventoryType, delay: Duration?): SingleGUI {
         return SingleFillGUI(plugin, serverMock, inventoryType, items, delay)
     }
 
@@ -120,6 +123,22 @@ class SingleGUITest : AbstractGUITest() {
     @Nested
     inner class UpdateClient : AbstractGUITest.UpdateClient()
 
+    @Nested
+    inner class Update {
+
+        @ParameterizedTest
+        @ValueSource(booleans = [true, false])
+        fun `should call update function with generic key`(result: Boolean) = runTest {
+            val gui = spyk(createNonFillGUI()) {
+                coEvery { update(Unit, result) } returns result
+            }
+
+            gui.update(result) shouldBe result
+            coVerify(exactly = 1) { gui.update(Unit, result) }
+        }
+
+    }
+
     @Nested
     inner class HasInventory : AbstractGUITest.HasInventory()
 

From 5b8337136d2be80953fd52c72bc2a826c9894815 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 13:54:05 +0100
Subject: [PATCH 39/50] test: Add test about shift  constructor

---
 .../ShiftInventoryLoadingAnimationTest.kt     | 68 ++++++++++++++++++-
 1 file changed, 67 insertions(+), 1 deletion(-)

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
index 6e03eb7b..75d7887e 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
@@ -1,18 +1,25 @@
 package com.github.rushyverse.api.gui.load
 
+import io.kotest.assertions.throwables.shouldNotThrow
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.collections.shouldContainExactly
 import io.kotest.matchers.shouldBe
 import io.mockk.every
 import io.mockk.mockk
+import java.util.*
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.nanoseconds
 import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
 
 class ShiftInventoryLoadingAnimationTest {
 
@@ -33,6 +40,30 @@ class ShiftInventoryLoadingAnimationTest {
         }
     }
 
+    @ParameterizedTest
+    @ValueSource(ints = [0, -1, -2, -3, -4, -5, -6, -7, -8])
+    fun `should throw if duration is not positive`(duration: Int) {
+        shouldThrow<IllegalArgumentException> {
+            ShiftInventoryLoadingAnimation<Unit>(
+                initialize = { emptySequence() },
+                shift = 1,
+                delay = duration.milliseconds
+            )
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [1, 2, 3, 4, 5, 6, 7, 8])
+    fun `should not throw if duration is positive`(duration: Int) {
+        shouldNotThrow<IllegalArgumentException> {
+            ShiftInventoryLoadingAnimation<Unit>(
+                initialize = { emptySequence() },
+                shift = 1,
+                delay = duration.nanoseconds
+            )
+        }
+    }
+
     @Test
     fun `should not change inventory if initialize is empty`() {
         val delay = 10.milliseconds
@@ -53,12 +84,21 @@ class ShiftInventoryLoadingAnimationTest {
 
     @Test
     fun `should just initialize if shift is zero`() = runBlocking {
+        shouldJustInitializeWithoutShift(0)
+    }
+
+    @Test
+    fun `should just initialize if shift is inventory size`() = runBlocking {
+        shouldJustInitializeWithoutShift(inventory.size)
+    }
+
+    private suspend fun shouldJustInitializeWithoutShift(shift: Int) = coroutineScope {
         val delay = 10.milliseconds
         val items = Array(inventory.size) { mockk<ItemStack>() }
 
         val animation = ShiftInventoryLoadingAnimation<Unit>(
             initialize = { items.asSequence() },
-            shift = 0,
+            shift = shift,
             delay = delay
         )
 
@@ -68,4 +108,30 @@ class ShiftInventoryLoadingAnimationTest {
 
         inventory.contents.toList() shouldContainExactly items.toList()
     }
+
+    @ParameterizedTest
+    @ValueSource(ints = [1, 2, 3, 4, 5, 6, 7, 8])
+    fun `should shift initialized items`(shift: Int) = runBlocking {
+        val delay = 100.milliseconds
+        val items = Array(inventory.size) { mockk<ItemStack>() }
+        val itemList = items.toList()
+
+        val animation = ShiftInventoryLoadingAnimation<Unit>(
+            initialize = { items.asSequence() },
+            shift = shift,
+            delay = delay
+        )
+
+        val job = launch { animation.loading(Unit, inventory) }
+
+        delay(delay / 2)
+        repeat(5) {
+            inventory.contents.toList() shouldContainExactly itemList
+            delay(delay)
+            Collections.rotate(itemList, shift)
+            job.isActive shouldBe true
+        }
+
+        job.cancelAndJoin()
+    }
 }

From f21da9c0433d9cac7753124ce26c3ff7353e6da5 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 13:55:58 +0100
Subject: [PATCH 40/50] chore: Remove property exception

---
 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index 3b4db03a..e9c03500 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -62,9 +62,8 @@ public class GUIClosedException(message: String? = null) : GUIException(message)
 
 /**
  * Exception thrown when the GUI is updating.
- * @property client Client for which the GUI is updating.
  */
-public class GUIUpdatedException(public val client: Client?) : GUIException()
+public class GUIUpdatedException : GUIException()
 
 /**
  * Exception thrown when the GUI is closed for a specific client.
@@ -163,7 +162,7 @@ public abstract class GUI<T>(
         val key = getKey(client)
         return mutex.withLock {
             if (!unsafeContains(client)) return false
-            unsafeUpdate(key, interruptLoading, client)
+            unsafeUpdate(key, interruptLoading)
         }
     }
 
@@ -181,7 +180,7 @@ public abstract class GUI<T>(
      * @return True if the inventory was updated, false otherwise.
      */
     public open suspend fun update(key: T, interruptLoading: Boolean = false): Boolean {
-        return mutex.withLock { unsafeUpdate(key, interruptLoading, null) }
+        return mutex.withLock { unsafeUpdate(key, interruptLoading) }
     }
 
     /**
@@ -199,7 +198,7 @@ public abstract class GUI<T>(
      * to start a new loading animation.
      * @return True if the inventory was updated, false otherwise.
      */
-    private suspend fun unsafeUpdate(key: T, interruptLoading: Boolean = false, cause: Client? = null): Boolean {
+    private suspend fun unsafeUpdate(key: T, interruptLoading: Boolean = false): Boolean {
         val inventoryData = inventories[key] ?: return false
 
         if (inventoryData.isLoading) {
@@ -209,7 +208,7 @@ public abstract class GUI<T>(
                 // If we want to interrupt the loading, we cancel the loading job.
                 // We need to wait for the job to be cancelled to avoid conflicts with the new loading animation.
                 inventoryData.job.apply {
-                    cancel(GUIUpdatedException(cause))
+                    cancel(GUIUpdatedException())
                     join()
                 }
             }

From 94bc53b46814644a72621ce290db5f36d817f4e7 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 14:01:45 +0100
Subject: [PATCH 41/50] test: Add check test about stop animation

---
 .../kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt | 8 ++++----
 .../api/gui/load/ShiftInventoryLoadingAnimationTest.kt    | 3 +++
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
index e674c8c8..38634edd 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -128,13 +128,13 @@ class SingleGUITest : AbstractGUITest() {
 
         @ParameterizedTest
         @ValueSource(booleans = [true, false])
-        fun `should call update function with generic key`(result: Boolean) = runTest {
+        fun `should call update function with generic key`(boolean: Boolean) = runTest {
             val gui = spyk(createNonFillGUI()) {
-                coEvery { update(Unit, result) } returns result
+                coEvery { update(Unit, boolean) } returns boolean
             }
 
-            gui.update(result) shouldBe result
-            coVerify(exactly = 1) { gui.update(Unit, result) }
+            gui.update(boolean) shouldBe boolean
+            coVerify(exactly = 1) { gui.update(Unit, boolean) }
         }
 
     }
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
index 75d7887e..8c1e8c9c 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/load/ShiftInventoryLoadingAnimationTest.kt
@@ -133,5 +133,8 @@ class ShiftInventoryLoadingAnimationTest {
         }
 
         job.cancelAndJoin()
+        delay(delay)
+        // The inventory should not have changed after the animation is finished.
+        inventory.contents.toList() shouldContainExactly itemList
     }
 }

From b35071d1abb2bdf902f08b949d7904b6e7d95a79 Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 16:12:31 +0100
Subject: [PATCH 42/50] fix: Rollback scope API plugin

---
 src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
index 7b0abcc6..e1b0480e 100644
--- a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
@@ -15,7 +15,7 @@ import org.bukkit.plugin.java.JavaPlugin
 /**
  * Plugin to enable the API in server.
  */
-public open class APIPlugin : JavaPlugin() {
+public class APIPlugin : JavaPlugin() {
 
     public companion object {
         /**

From 728ae8773b68d45c09906b72a1c85920d1b8179f Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Wed, 20 Dec 2023 19:16:27 +0100
Subject: [PATCH 43/50] chore: Remove unused method

---
 .../rushyverse/api/extension/_String.kt       | 19 ++-----------------
 1 file changed, 2 insertions(+), 17 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt b/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt
index 63ab7bfa..3a59a649 100644
--- a/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/extension/_String.kt
@@ -3,16 +3,14 @@
 
 package com.github.rushyverse.api.extension
 
-import com.github.rushyverse.api.translation.Translator
-import com.github.rushyverse.api.translation.getComponent
+import java.math.BigInteger
+import java.util.*
 import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.TextComponent
 import net.kyori.adventure.text.format.NamedTextColor
 import net.kyori.adventure.text.minimessage.MiniMessage
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver
 import net.kyori.adventure.text.minimessage.tag.standard.StandardTags
-import java.math.BigInteger
-import java.util.*
 
 /**
  * MiniMessage instance to deserialize components without strict mode.
@@ -265,16 +263,3 @@ public fun StringBuilder.deleteLast(size: Int): StringBuilder {
         else -> delete(length - size, length)
     }
 }
-
-/**
- * If the string contains a dot, it will be considered as a translation path, and will be translated.
- * However, if the string doesn't contain a dot, it will be considered as a component.
- * @receiver String to translate or to convert to a component.
- * @param translator Translator.
- * @param locale Locale to use for translation.
- * @return The translated component or the component created from the string.
- */
-public fun String.toTranslatedComponent(translator: Translator, locale: Locale): Component {
-    return if (this.contains('.')) translator.getComponent(this, locale)
-    else this.asComponent()
-}

From 3259de410e253ed263f089b92819fe2086f17b4d Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Thu, 21 Dec 2023 14:50:35 +0100
Subject: [PATCH 44/50] fix: remove & move right click item on click inventory

---
 .../rushyverse/api/extension/event/_Event.kt  | 37 +++++++++++
 .../github/rushyverse/api/gui/GUIListener.kt  | 51 +-------------
 .../api/extension/event/EventExtTest.kt       | 66 +++++++++++++++++++
 .../rushyverse/api/gui/GUIListenerTest.kt     | 36 ----------
 4 files changed, 106 insertions(+), 84 deletions(-)
 create mode 100644 src/test/kotlin/com/github/rushyverse/api/extension/event/EventExtTest.kt

diff --git a/src/main/kotlin/com/github/rushyverse/api/extension/event/_Event.kt b/src/main/kotlin/com/github/rushyverse/api/extension/event/_Event.kt
index f1f1e25a..444d7b50 100644
--- a/src/main/kotlin/com/github/rushyverse/api/extension/event/_Event.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/extension/event/_Event.kt
@@ -1,7 +1,16 @@
 package com.github.rushyverse.api.extension.event
 
+import com.github.shynixn.mccoroutine.bukkit.callSuspendingEvent
+import kotlinx.coroutines.joinAll
+import org.bukkit.Bukkit
+import org.bukkit.block.BlockFace
 import org.bukkit.entity.Damageable
+import org.bukkit.entity.Player
+import org.bukkit.event.block.Action
 import org.bukkit.event.entity.EntityDamageEvent
+import org.bukkit.event.player.PlayerInteractEvent
+import org.bukkit.inventory.ItemStack
+import org.bukkit.plugin.Plugin
 
 /**
  * Future life of the damaged entity.
@@ -15,3 +24,31 @@ public fun EntityDamageEvent.finalDamagedHealth(): Double? {
         null
     }
 }
+
+/**
+ * Create a [PlayerInteractEvent] to simulate a right click with an item for a player and call it.
+ * @param plugin Plugin to call the event.
+ * @param player Player who clicked.
+ * @param item Item that was clicked.
+ */
+public suspend fun callRightClickOnItemEvent(plugin: Plugin, player: Player, item: ItemStack) {
+    val rightClickWithItemEvent = createRightClickEventWithItem(player, item)
+    Bukkit.getPluginManager().callSuspendingEvent(rightClickWithItemEvent, plugin).joinAll()
+}
+
+/**
+ * Create a PlayerInteractEvent to simulate a right click with an item.
+ * @param player Player who clicked.
+ * @param item Item that was clicked.
+ * @return The new event.
+ */
+private fun createRightClickEventWithItem(
+    player: Player,
+    item: ItemStack
+) = PlayerInteractEvent(
+    player,
+    Action.RIGHT_CLICK_AIR,
+    item,
+    null,
+    BlockFace.NORTH // random value not null
+)
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
index 276c56d0..3609bb14 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUIListener.kt
@@ -4,22 +4,14 @@ import com.github.rushyverse.api.Plugin
 import com.github.rushyverse.api.extension.event.cancel
 import com.github.rushyverse.api.koin.inject
 import com.github.rushyverse.api.player.ClientManager
-import com.github.shynixn.mccoroutine.bukkit.callSuspendingEvent
-import kotlinx.coroutines.joinAll
 import org.bukkit.Material
-import org.bukkit.Server
-import org.bukkit.block.BlockFace
 import org.bukkit.entity.HumanEntity
-import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
-import org.bukkit.event.block.Action
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
-import org.bukkit.event.player.PlayerInteractEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
-import org.bukkit.inventory.PlayerInventory
 
 /**
  * Listener for GUI events.
@@ -29,8 +21,6 @@ public class GUIListener(private val plugin: Plugin) : Listener {
 
     private val clients: ClientManager by inject(plugin.id)
 
-    private val server: Server by inject()
-
     /**
      * Called when a player clicks on an item in an inventory.
      * If the click is detected in a GUI, the event is cancelled and the GUI is notified.
@@ -48,11 +38,7 @@ public class GUIListener(private val plugin: Plugin) : Listener {
         val clickedInventory = event.clickedInventory ?: return
 
         val player = event.whoClicked
-        if (clickedInventory is PlayerInventory) {
-            handleClickOnPlayerInventory(player as Player, item, event)
-        } else {
-            handleClickOnGUI(player, clickedInventory, item, event)
-        }
+        handleClickOnGUI(player, clickedInventory, item, event)
     }
 
     /**
@@ -79,37 +65,6 @@ public class GUIListener(private val plugin: Plugin) : Listener {
         gui.onClick(client, clickedInventory, item, event)
     }
 
-    /**
-     * Called when a player clicks on an item in his inventory.
-     * To trigger the action linked to the clicked item,
-     * we produce a PlayerInteractEvent to simulate a right click with the item.
-     * @param player Player who clicked.
-     * @param item Item that was clicked.
-     */
-    private suspend fun handleClickOnPlayerInventory(player: Player, item: ItemStack, event: InventoryClickEvent) {
-        event.cancel()
-
-        val rightClickWithItemEvent = createRightClickWithItemEvent(player, item)
-        server.pluginManager.callSuspendingEvent(rightClickWithItemEvent, plugin).joinAll()
-    }
-
-    /**
-     * Create a PlayerInteractEvent to simulate a right click with an item.
-     * @param player Player who clicked.
-     * @param item Item that was clicked.
-     * @return The new event.
-     */
-    private fun createRightClickWithItemEvent(
-        player: Player,
-        item: ItemStack
-    ) = PlayerInteractEvent(
-        player,
-        Action.RIGHT_CLICK_AIR,
-        item,
-        null,
-        BlockFace.NORTH // random value not null
-    )
-
     /**
      * Called when a player closes an inventory.
      * If the inventory is a GUI, the GUI is notified that it is closed for this player.
@@ -117,8 +72,8 @@ public class GUIListener(private val plugin: Plugin) : Listener {
      */
     @EventHandler
     public suspend fun onInventoryClose(event: InventoryCloseEvent) {
-        val client = clients.getClientOrNull(event.player)
-        val gui = client?.gui() ?: return
+        val client = clients.getClientOrNull(event.player) ?: return
+        val gui = client.gui() ?: return
         // We don't close the inventory because it is closing due to event.
         // That avoids an infinite loop of events and consequently a stack overflow.
         gui.closeClient(client, false)
diff --git a/src/test/kotlin/com/github/rushyverse/api/extension/event/EventExtTest.kt b/src/test/kotlin/com/github/rushyverse/api/extension/event/EventExtTest.kt
new file mode 100644
index 00000000..f54c2817
--- /dev/null
+++ b/src/test/kotlin/com/github/rushyverse/api/extension/event/EventExtTest.kt
@@ -0,0 +1,66 @@
+package com.github.rushyverse.api.extension.event
+
+import be.seeseemelk.mockbukkit.MockBukkit
+import be.seeseemelk.mockbukkit.ServerMock
+import com.github.rushyverse.api.extension.ItemStack
+import com.github.shynixn.mccoroutine.bukkit.callSuspendingEvent
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.unmockkAll
+import io.mockk.verify
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.bukkit.Material
+import org.bukkit.event.block.Action
+import org.bukkit.event.player.PlayerInteractEvent
+
+class EventExtTest {
+
+    private lateinit var serverMock: ServerMock
+
+    @BeforeTest
+    fun onBefore() {
+        serverMock = MockBukkit.mock()
+        mockkStatic("com.github.shynixn.mccoroutine.bukkit.MCCoroutineKt")
+    }
+
+    @AfterTest
+    fun onAfter() {
+        MockBukkit.unmock()
+        unmockkAll()
+    }
+
+    @Test
+    fun `should trigger right click`() = runTest {
+        val plugin = MockBukkit.createMockPlugin()
+        val player = serverMock.addPlayer()
+        val item = ItemStack { type = Material.DIRT }
+        val slot = slot<PlayerInteractEvent>()
+
+        lateinit var jobs: List<Job>
+        val pluginManager = serverMock.pluginManager
+        every { pluginManager.callSuspendingEvent(capture(slot), plugin) } answers {
+            List(5) { async { delay(1.seconds) } }.apply { jobs = this }
+        }
+
+        callRightClickOnItemEvent(plugin, player, item)
+
+        verify(exactly = 1) { pluginManager.callSuspendingEvent(any(), plugin) }
+        jobs.forEach { it.isCompleted shouldBe true }
+
+        val event = slot.captured
+        event.player shouldBe player
+        event.action shouldBe Action.RIGHT_CLICK_AIR
+        event.item shouldBe item
+        event.clickedBlock shouldBe null
+    }
+
+}
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
index 2a86c9ed..4b5d1566 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/GUIListenerTest.kt
@@ -9,30 +9,23 @@ import com.github.rushyverse.api.player.Client
 import com.github.rushyverse.api.player.ClientManager
 import com.github.rushyverse.api.player.ClientManagerImpl
 import com.github.shynixn.mccoroutine.bukkit.callSuspendingEvent
-import io.kotest.matchers.shouldBe
 import io.mockk.coEvery
 import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.mockkStatic
-import io.mockk.slot
 import io.mockk.unmockkAll
 import io.mockk.verify
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
-import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.async
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.test.runTest
 import org.bukkit.Material
 import org.bukkit.entity.Player
-import org.bukkit.event.block.Action
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
-import org.bukkit.event.player.PlayerInteractEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 import org.junit.jupiter.api.Nested
@@ -116,35 +109,6 @@ class GUIListenerTest : AbstractKoinTest() {
             verify(exactly = 0) { pluginManager.callSuspendingEvent(any(), plugin) }
         }
 
-        @Test
-        fun `should trigger right click event if player select his own inventory`() = runTest {
-            val (player, client) = registerPlayer()
-            val gui = registerGUI {
-                coEvery { contains(client) } returns false
-            }
-
-            val pluginManager = server.pluginManager
-
-            val slot = slot<PlayerInteractEvent>()
-            val jobs = List(5) {
-                async { delay(1.seconds) }
-            }
-            every { pluginManager.callSuspendingEvent(capture(slot), plugin) } returns jobs
-
-            val item = ItemStack { type = Material.DIRT }
-
-            callEvent(false, player, item, player.inventory)
-            coVerify(exactly = 0) { gui.onClick(any(), any(), any(), any()) }
-            verify(exactly = 1) { pluginManager.callSuspendingEvent(any(), plugin) }
-            jobs.forEach { it.isCompleted shouldBe true }
-
-            val event = slot.captured
-            event.player shouldBe player
-            event.action shouldBe Action.RIGHT_CLICK_AIR
-            event.item shouldBe item
-            event.clickedBlock shouldBe null
-        }
-
         @Test
         fun `should call GUI onClick if client has opened one`() = runTest {
             val (player, client) = registerPlayer()

From 2fd21151ce1bcdc2a19e2fcff4c5e7100db4bbbe Mon Sep 17 00:00:00 2001
From: Distractic <distractic@outlook.fr>
Date: Sat, 23 Dec 2023 07:28:39 +0100
Subject: [PATCH 45/50] chore: Remove await cancellation

---
 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index e9c03500..ad0f2f63 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -7,7 +7,6 @@ import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.asFlow
@@ -264,12 +263,7 @@ public abstract class GUI<T>(
                 // Will fill the inventory bit by bit.
                 inventoryFlowItems.collect { (index, item) -> inventory.setItem(index, item) }
             } else {
-                val loadingAnimationJob = launch {
-                    loadingAnimation.loading(key, inventory)
-                    // If the loading function is finished, the "loading" state must be continued
-                    // until the flow is finished.
-                    awaitCancellation()
-                }
+                val loadingAnimationJob = launch { loadingAnimation.loading(key, inventory) }
 
                 // To avoid conflicts with the loading animation,
                 // we need to store the items in a temporary inventory

From 0ad4fa6d3de91262c5a374f098b829c0abe07041 Mon Sep 17 00:00:00 2001
From: Cizetux <cizetux@gmail.com>
Date: Wed, 3 Jan 2024 17:13:47 +0100
Subject: [PATCH 46/50] refactor: Add suspend modifier to 'createInventory'
 across multiple classes

---
 src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt          | 2 +-
 src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt    | 4 ++--
 src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt    | 4 ++--
 .../com/github/rushyverse/api/gui/LocalePlayerGUITest.kt      | 2 +-
 .../kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt     | 2 +-
 .../kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt     | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
index ad0f2f63..fb354055 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/GUI.kt
@@ -288,7 +288,7 @@ public abstract class GUI<T>(
      * @param key Key to create the inventory for.
      * @return New created inventory.
      */
-    protected abstract fun createInventory(key: T): Inventory
+    protected abstract suspend fun createInventory(key: T): Inventory
 
     /**
      * Create a new flow of [Item][ItemStack] to fill the inventory with.
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
index c94ca7ae..d0238193 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/PlayerGUI.kt
@@ -42,7 +42,7 @@ public abstract class PlayerGUI(
      * @param key The client to create the inventory for.
      * @return The inventory for the client.
      */
-    override fun createInventory(key: Client): Inventory {
+    override suspend fun createInventory(key: Client): Inventory {
         val player = key.requirePlayer()
         return createInventory(player, key)
     }
@@ -54,7 +54,7 @@ public abstract class PlayerGUI(
      * @param client The client to create the inventory for.
      * @return The inventory for the client.
      */
-    protected abstract fun createInventory(owner: InventoryHolder, client: Client): Inventory
+    protected abstract suspend fun createInventory(owner: InventoryHolder, client: Client): Inventory
 
     override suspend fun closeClient(client: Client, closeInventory: Boolean): Boolean {
         val (inventory, job) = mutex.withLock { inventories.remove(client) } ?: return false
diff --git a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
index ba9a2817..47b5ae5e 100644
--- a/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/gui/SingleGUI.kt
@@ -44,7 +44,7 @@ public abstract class SingleGUI(
         return scope + SupervisorJob(scope.coroutineContext.job)
     }
 
-    override fun createInventory(key: Unit): Inventory {
+    override suspend fun createInventory(key: Unit): Inventory {
         return createInventory()
     }
 
@@ -52,7 +52,7 @@ public abstract class SingleGUI(
      * Create the inventory.
      * @return New created inventory.
      */
-    protected abstract fun createInventory(): Inventory
+    protected abstract suspend fun createInventory(): Inventory
 
     /**
      * Update the inventory.
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
index 940d583e..4249e861 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/LocalePlayerGUITest.kt
@@ -206,7 +206,7 @@ private abstract class AbstractLocaleGUITest(
     animation: InventoryLoadingAnimation<Locale>? = null
 ) : LocaleGUI(plugin, animation) {
 
-    override fun createInventory(key: Locale): Inventory {
+    override suspend fun createInventory(key: Locale): Inventory {
         return serverMock.createInventory(null, type)
     }
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
index 5213edae..3672cda5 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/PlayerGUITest.kt
@@ -174,7 +174,7 @@ private abstract class AbstractPlayerGUITest(
     loadingAnimation: InventoryLoadingAnimation<Client>? = null
 ) : PlayerGUI(loadingAnimation) {
 
-    override fun createInventory(owner: InventoryHolder, client: Client): Inventory {
+    override suspend fun createInventory(owner: InventoryHolder, client: Client): Inventory {
         return serverMock.createInventory(owner, type)
     }
 
diff --git a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
index 38634edd..51601e76 100644
--- a/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
+++ b/src/test/kotlin/com/github/rushyverse/api/gui/SingleGUITest.kt
@@ -192,7 +192,7 @@ private abstract class AbstractSingleGUITest(
     animation: InventoryLoadingAnimation<Unit>? = null
 ) : SingleGUI(plugin, animation) {
 
-    override fun createInventory(): Inventory {
+    override suspend fun createInventory(): Inventory {
         return serverMock.createInventory(null, type)
     }
 

From c4651307bf979c9780beb659deb87cf33d40e42f Mon Sep 17 00:00:00 2001
From: Cizetux <cizetux@gmail.com>
Date: Sat, 7 Sep 2024 17:25:53 +0200
Subject: [PATCH 47/50] refactor: Add data colors to each GameState

---
 .../com/github/rushyverse/api/game/GameState.kt | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/main/kotlin/com/github/rushyverse/api/game/GameState.kt b/src/main/kotlin/com/github/rushyverse/api/game/GameState.kt
index 7029f34e..b66df1fe 100644
--- a/src/main/kotlin/com/github/rushyverse/api/game/GameState.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/game/GameState.kt
@@ -1,33 +1,40 @@
 package com.github.rushyverse.api.game
 
+import net.kyori.adventure.text.format.NamedTextColor
+
 /**
  * Represents the various states a game can be in at any given moment.
  * Each state corresponds to a different phase in the game's lifecycle.
  */
-public enum class GameState {
+public enum class GameState(
+    public val color: NamedTextColor,
+    public val miniColor: String,
+) {
+
+    NOT_STARTED(NamedTextColor.BLUE, "<blue>"),
 
     /**
      * Represents the state where the game is waiting for necessary conditions to start.
      * This could be waiting for more players to join, or waiting for some setup process to finish.
      */
-    WAITING,
+    WAITING(NamedTextColor.GOLD, "<gold>"),
 
     /**
      * Represents the state when the game is in the process of starting.
      * This is a transitional phase, initialization of game resources,
      * a countdown timer before the game starts, etc.
      */
-    STARTING,
+    STARTING(NamedTextColor.YELLOW, "<yellow>"),
 
     /**
      * Represents the state where the game has officially started.
      * Gameplay is active during this state.
      */
-    STARTED,
+    STARTED(NamedTextColor.GREEN, "<green>"),
 
     /**
      * Represents the state when the game is in the process of ending.
      * This is a transitional phase, where final scores might be calculated, game resources might be cleaned up, etc.
      */
-    ENDING;
+    ENDED(NamedTextColor.RED, "<red>");
 }

From 8f7281dff41193222e0149db25789bdc50f12317 Mon Sep 17 00:00:00 2001
From: Cizetux <cizetux@gmail.com>
Date: Sat, 7 Sep 2024 17:27:51 +0200
Subject: [PATCH 48/50] refactor: Add 'permanent' field to handle games that
 are in permanent mode

---
 src/main/kotlin/com/github/rushyverse/api/game/GameData.kt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/kotlin/com/github/rushyverse/api/game/GameData.kt b/src/main/kotlin/com/github/rushyverse/api/game/GameData.kt
index 0266b918..0b229ec4 100644
--- a/src/main/kotlin/com/github/rushyverse/api/game/GameData.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/game/GameData.kt
@@ -13,4 +13,5 @@ public data class GameData(
     val id: Int,
     var players: Int = 0,
     var state: GameState = GameState.WAITING,
+    val permanent: Boolean = false
 )

From 6939b93a60bb82670df220c81ed3c039bdfc3615 Mon Sep 17 00:00:00 2001
From: Cizetux <cizetux@gmail.com>
Date: Fri, 15 May 2026 12:35:41 +0200
Subject: [PATCH 49/50] chore: update dependencies to latest versions

---
 build.gradle.kts                         |  27 +++++++------
 gradle/wrapper/gradle-wrapper.jar        | Bin 59821 -> 43764 bytes
 gradle/wrapper/gradle-wrapper.properties |   4 +-
 gradlew                                  |  47 +++++++++++++++--------
 gradlew.bat                              |  41 +++++++++++---------
 5 files changed, 73 insertions(+), 46 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 153f3e40..da8d12d2 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -30,22 +30,23 @@ repositories {
     mavenCentral()
     maven("https://repo.papermc.io/repository/maven-public/")
     maven("https://repo.codemc.org/repository/maven-public/")
+    maven("https://repo.mockbukkit.org/repository/maven-public/")
     maven("https://jitpack.io")
 }
 
 dependencies {
-    val kotlinSerializableVersion = "1.6.0"
+    val kotlinSerializableVersion = "1.7.3"
     val kamlVersion = "0.55.0"
-    val coroutineVersion = "1.6.4"
+    val coroutineVersion = "1.8.1"
     val loggingVersion = "3.0.5"
-    val koinVersion = "3.4.3"
-    val mccoroutineVersion = "2.13.0"
-    val paperVersion = "1.20-R0.1-SNAPSHOT"
-    val mockBukkitVersion = "3.19.1"
+    val koinVersion = "3.5.6"
+    val mccoroutineVersion = "2.14.0"
+    val paperVersion = "1.21.11-R0.1-SNAPSHOT"
+    // val mockBukkitVersion = "4.4.0"
     val junitVersion = "5.10.0"
-    val mockkVersion = "1.12.5"
+    val mockkVersion = "1.14.9"
     val fastboardVersion = "2.0.0"
-    val kotestVersion = "5.6.2"
+    val kotestVersion = "5.9.1"
     val icu4jVersion = "73.2"
 
     api(kotlin("stdlib"))
@@ -77,10 +78,10 @@ dependencies {
     // Scoreboard framework
     api("fr.mrmicky:fastboard:$fastboardVersion")
 
-    api("com.github.Rushyverse:core:6ae31a9250")
+    // api("com.github.Rushyverse:core:6ae31a9250")
 
     // Tests
-    testImplementation("com.github.seeseemelk:MockBukkit-v1.20:$mockBukkitVersion")
+    // testImplementation("org.mockbukkit.mockbukkit:mockbukkit-$mockBukkitVersion")
     testImplementation(kotlin("test-junit5"))
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutineVersion")
     testImplementation("io.kotest:kotest-assertions-core:$kotestVersion")
@@ -94,7 +95,7 @@ dependencies {
     testImplementation("io.mockk:mockk:$mockkVersion")
 }
 
-val javaVersion get() = JavaVersion.VERSION_17
+val javaVersion get() = JavaVersion.VERSION_21
 val javaVersionString get() = javaVersion.toString()
 val javaVersionInt get() = javaVersionString.toInt()
 
@@ -123,7 +124,9 @@ val dokkaOutputDir = "${rootProject.projectDir}/dokka"
 
 tasks {
     withType<KotlinCompile> {
-        kotlinOptions.jvmTarget = javaVersionString
+        compilerOptions {
+            jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.fromTarget(javaVersionString))
+        }
     }
 
     withType<JavaCompile> {
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 41d9927a4d4fb3f96a785543079b8df6723c946b..1b33c55baabb587c669f562ae36f953de2481846 100644
GIT binary patch
literal 43764
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
Mi07c5C&+LA2gVWY(f|Me

literal 59821
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

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index a5952066..aaaabb3c 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.4-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index 1b6c7873..23d15a93 100644
--- a/gradlew
+++ b/gradlew
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -80,13 +82,11 @@ do
     esac
 done
 
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
+# This is normally unused
+# shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -114,7 +114,7 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+CLASSPATH="\\\"\\\""
 
 
 # Determine the Java command to use to start the JVM.
@@ -133,22 +133,29 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
     case $MAX_FD in  #(
       '' | soft) :;; #(
       *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -193,18 +200,28 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
         -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
 # Use "xargs" to parse quoted args.
 #
 # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
diff --git a/gradlew.bat b/gradlew.bat
index 107acd32..db3a6ac2 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,8 +13,10 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +27,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -56,32 +59,34 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+set CLASSPATH=
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

From 74469b35584df592926956bcd64ab546aa35709f Mon Sep 17 00:00:00 2001
From: Cizetux <cizetux@gmail.com>
Date: Fri, 29 May 2026 12:42:13 +0200
Subject: [PATCH 50/50] feat: add rank system and update dependencies

---
 build.gradle.kts                              | 22 +++++++++++++++----
 .../com/github/rushyverse/api/APIPlugin.kt    |  1 +
 .../github/rushyverse/api/rank/RankType.kt    | 21 ++++++++++++++++++
 .../api/serializer/PatternTypeSerializer.kt   | 15 ++++---------
 4 files changed, 44 insertions(+), 15 deletions(-)
 create mode 100644 src/main/kotlin/com/github/rushyverse/api/rank/RankType.kt

diff --git a/build.gradle.kts b/build.gradle.kts
index da8d12d2..a06b9b29 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -2,8 +2,10 @@ import io.gitlab.arturbosch.detekt.Detekt
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    embeddedKotlin("jvm")
-    embeddedKotlin("plugin.serialization")
+    //embeddedKotlin("jvm")
+    //embeddedKotlin("plugin.serialization")
+    kotlin("jvm") version "2.2.0"
+    kotlin("plugin.serialization") version "2.2.0"
     id("org.jetbrains.dokka") version "1.9.0"
     id("com.github.johnrengelman.shadow") version "8.1.1"
     id("io.gitlab.arturbosch.detekt") version "1.23.1"
@@ -27,10 +29,11 @@ jacoco {
 }
 
 repositories {
+    mavenLocal()
     mavenCentral()
     maven("https://repo.papermc.io/repository/maven-public/")
     maven("https://repo.codemc.org/repository/maven-public/")
-    maven("https://repo.mockbukkit.org/repository/maven-public/")
+    // maven("https://repo.mockbukkit.org/repository/maven-public/")
     maven("https://jitpack.io")
 }
 
@@ -45,7 +48,7 @@ dependencies {
     // val mockBukkitVersion = "4.4.0"
     val junitVersion = "5.10.0"
     val mockkVersion = "1.14.9"
-    val fastboardVersion = "2.0.0"
+    val fastboardVersion = "2.1.5"
     val kotestVersion = "5.9.1"
     val icu4jVersion = "73.2"
 
@@ -79,6 +82,11 @@ dependencies {
     api("fr.mrmicky:fastboard:$fastboardVersion")
 
     // api("com.github.Rushyverse:core:6ae31a9250")
+    api("com.github.Rushyverse:core:2.0.0")
+
+    api("org.komapper:komapper-dialect-postgresql-r2dbc:1.12.0")
+    api("io.r2dbc:r2dbc-spi:1.0.0.RELEASE")
+    api("org.postgresql:r2dbc-postgresql:1.0.5.RELEASE")
 
     // Tests
     // testImplementation("org.mockbukkit.mockbukkit:mockbukkit-$mockBukkitVersion")
@@ -165,6 +173,12 @@ tasks {
             csv.required.set(false)
         }
     }
+
+    shadowJar {
+        archiveClassifier.set("all")
+        mergeServiceFiles()
+        append("META-INF/services/org.komapper.r2dbc.spi.R2dbcDialectFactory")
+    }
 }
 
 val deleteDokkaOutputDir by tasks.register<Delete>("deleteDokkaOutputDirectory") {
diff --git a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
index e1b0480e..ebb0fa26 100644
--- a/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/APIPlugin.kt
@@ -31,6 +31,7 @@ public class APIPlugin : JavaPlugin() {
     }
 
     override fun onEnable() {
+        Thread.currentThread().contextClassLoader = this::class.java.classLoader
         super.onEnable()
         CraftContext.startKoin(ID_API)
         loadModule(ID_API) {
diff --git a/src/main/kotlin/com/github/rushyverse/api/rank/RankType.kt b/src/main/kotlin/com/github/rushyverse/api/rank/RankType.kt
new file mode 100644
index 00000000..a26e0521
--- /dev/null
+++ b/src/main/kotlin/com/github/rushyverse/api/rank/RankType.kt
@@ -0,0 +1,21 @@
+package com.github.rushyverse.api.rank
+
+import net.kyori.adventure.text.format.NamedTextColor
+
+public enum class RankType(
+    public val displayName: String,
+    public val color: NamedTextColor,
+    public val weight: Int
+) {
+    // Staff
+    ADMIN("Admin", NamedTextColor.RED, 100),
+    MODO("Modo", NamedTextColor.GOLD, 90),
+
+    // Joueurs
+    ASTRO("Astro", NamedTextColor.LIGHT_PURPLE, 30),
+    JEDI("Jedi", NamedTextColor.AQUA, 20),
+    VIP("VIP", NamedTextColor.GREEN, 10),
+
+    // Default
+    PLAYER("Player", NamedTextColor.GRAY, 0)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/github/rushyverse/api/serializer/PatternTypeSerializer.kt b/src/main/kotlin/com/github/rushyverse/api/serializer/PatternTypeSerializer.kt
index 7e937e04..40757071 100644
--- a/src/main/kotlin/com/github/rushyverse/api/serializer/PatternTypeSerializer.kt
+++ b/src/main/kotlin/com/github/rushyverse/api/serializer/PatternTypeSerializer.kt
@@ -8,18 +8,10 @@ import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import org.bukkit.block.banner.PatternType
 
-/**
- * Serializer for [PatternType].
- */
 public object PatternTypeSerializer : KSerializer<PatternType> {
 
-    private val enumSerializer = EnumSerializer("patternTypeEnum", PatternType.entries)
-
     override val descriptor: SerialDescriptor
-        get() = PrimitiveSerialDescriptor(
-            "patternType",
-            PrimitiveKind.STRING
-        )
+        get() = PrimitiveSerialDescriptor("patternType", PrimitiveKind.STRING)
 
     override fun serialize(encoder: Encoder, value: PatternType) {
         encoder.encodeString(value.identifier)
@@ -27,6 +19,7 @@ public object PatternTypeSerializer : KSerializer<PatternType> {
 
     override fun deserialize(decoder: Decoder): PatternType {
         val key = decoder.decodeString()
-        return PatternType.getByIdentifier(key.lowercase()) ?: enumSerializer.findEnumValue(key)
+        return PatternType.getByIdentifier(key.lowercase())
+            ?: throw IllegalArgumentException("Unknown PatternType: $key")
     }
-}
+}
\ No newline at end of file