Add player status display and filter toggle to challenge menu

- Add player-specific status labels (Not joined, Active, Failed, Completed) to challenge menu items
- Implement efficient database JOIN queries to eliminate N+1 query performance issues
- Add filter toggle to switch between "Your Challenges" and "All Challenges" views
- Include completed/failed challenges in menu display with proper status tracking
- Fix challenge completion database persistence to update status correctly
- Add internationalization support for new status labels in English and German

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: finreinhard

src/main/kotlin/li/angu/challengeplugin/managers/ChallengeManager.kt

@@ -8,6 +8,7 @@ import org.bukkit.Bukkit
 import org.bukkit.World
 import org.bukkit.WorldCreator
 import org.bukkit.GameRule
+import org.bukkit.GameMode
 import org.bukkit.entity.Player
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
@@ -16,6 +17,36 @@ import java.time.Duration
 import java.time.Instant
 import java.io.File
 
+    data class ChallengeMenuData(
+    val id: UUID,
+    val name: String,
+    val status: ChallengeStatus,
+    val playerCount: Int,
+    val startedAt: Instant?,
+    val pausedAt: Instant?,
+    val totalPausedDuration: Duration,
+    val playerStatus: String
+) {
+    fun getFormattedDuration(): String {
+        if (startedAt == null) {
+            return "Not started"
+        }
+
+        val end = if (status != ChallengeStatus.ACTIVE) {
+            Instant.now() // For completed/failed challenges, use current time as end
+        } else if (pausedAt != null) {
+            pausedAt
+        } else {
+            Instant.now()
+        }
+
+        val rawDuration = Duration.between(startedAt, end)
+        val effectiveDuration = rawDuration.minus(totalPausedDuration)
+
+        return li.angu.challengeplugin.utils.TimeFormatter.formatDuration(effectiveDuration)
+    }
+}
+
 class ChallengeManager(private val plugin: ChallengePluginPlugin) {
 
     private val activeChallenges = ConcurrentHashMap<UUID, Challenge>()
@@ -98,7 +129,7 @@ class ChallengeManager(private val plugin: ChallengePluginPlugin) {
                     }
                 }
             }
-            
+
             plugin.logger.info("Loaded ${activeChallenges.size} challenges from database")
 
             // Load players for each challenge
@@ -537,6 +568,9 @@ class ChallengeManager(private val plugin: ChallengePluginPlugin) {
 
         challenge.complete()
 
+        // Save updated status to database
+        saveChallengeToDatabase(challenge)
+
         // Handle rewards or other completion logic
         Bukkit.getOnlinePlayers().forEach { player ->
             if (challenge.isPlayerInChallenge(player)) {
@@ -649,4 +683,97 @@ class ChallengeManager(private val plugin: ChallengePluginPlugin) {
             null
         }
     }
+
+    /**
+     * Get challenges for menu with minimal data and player status using efficient JOIN query
+     */
+    fun getChallengesForMenu(playerId: UUID, showAll: Boolean, limit: Int = 36): List<ChallengeMenuData> {
+        val query = if (showAll) {
+            """
+            SELECT c.id, c.name, c.status, c.started_at, c.paused_at, c.total_paused_duration,
+                   COUNT(cp.player_uuid) as player_count,
+                   pcd.game_mode, pcd.saved_at
+            FROM challenges c
+            LEFT JOIN challenge_participants cp ON c.id = cp.challenge_id
+            LEFT JOIN player_challenge_data pcd ON c.id = pcd.challenge_id AND pcd.player_uuid = ?
+            GROUP BY c.id, c.name, c.status, c.started_at, c.paused_at, c.total_paused_duration, pcd.game_mode, pcd.saved_at
+            ORDER BY (SELECT MAX(pcd2.saved_at) FROM player_challenge_data pcd2 WHERE pcd2.challenge_id = c.id) DESC NULLS LAST
+            LIMIT ?
+            """.trimIndent()
+        } else {
+            """
+            SELECT c.id, c.name, c.status, c.started_at, c.paused_at, c.total_paused_duration,
+                   COUNT(cp.player_uuid) as player_count,
+                   pcd.game_mode, pcd.saved_at
+            FROM challenges c
+            LEFT JOIN challenge_participants cp ON c.id = cp.challenge_id
+            LEFT JOIN player_challenge_data pcd ON c.id = pcd.challenge_id AND pcd.player_uuid = ?
+            LEFT JOIN challenge_participants cp2 ON c.id = cp2.challenge_id AND cp2.player_uuid = ?
+            GROUP BY c.id, c.name, c.status, c.started_at, c.paused_at, c.total_paused_duration, pcd.game_mode, pcd.saved_at
+            ORDER BY COALESCE(pcd.saved_at, cp.left_at, cp.joined_at) DESC
+            LIMIT ?
+            """.trimIndent()
+        }
+
+        val resultCallback = { rs: java.sql.ResultSet ->
+            val results = mutableListOf<ChallengeMenuData>()
+
+            while (rs.next()) {
+                try {
+                    val challengeId = UUID.fromString(rs.getString("id"))
+                    val status = ChallengeStatus.valueOf(rs.getString("status"))
+
+                    val startedAt = rs.getTimestamp("started_at")?.toInstant()
+                    val pausedAt = rs.getTimestamp("paused_at")?.toInstant()
+                    val totalPausedDuration = Duration.ofSeconds(rs.getLong("total_paused_duration"))
+
+                    val playerStatus = determinePlayerStatusFromDB(playerId, challengeId, status, rs.getString("game_mode"))
+
+                    results.add(ChallengeMenuData(
+                        id = challengeId,
+                        name = rs.getString("name"),
+                        status = status,
+                        playerCount = rs.getInt("player_count"),
+                        startedAt = startedAt,
+                        pausedAt = pausedAt,
+                        totalPausedDuration = totalPausedDuration,
+                        playerStatus = playerStatus
+                    ))
+
+                } catch (e: Exception) {
+                    plugin.logger.warning("Failed to load challenge menu data: ${e.message}")
+                }
+            }
+            results
+        }
+
+        return if (showAll) {
+            plugin.databaseDriver.executeQuery(query, playerId.toString(), limit, processor = resultCallback)
+        } else {
+            plugin.databaseDriver.executeQuery(query, playerId.toString(), playerId.toString(), limit, processor = resultCallback)
+        } ?: emptyList()
+    }
+
+    private fun determinePlayerStatusFromDB(playerId: UUID, challengeId: UUID, challengeStatus: ChallengeStatus, savedGameMode: String?): String {
+        // Check if player is currently active (in memory)
+        val challenge = activeChallenges[challengeId]
+        val player = plugin.server.getPlayer(playerId)
+        if (challenge != null && player != null && challenge.isPlayerInChallenge(player)) {
+            return "active"
+        }
+
+        // Check if player has saved data
+        if (savedGameMode != null) {
+            return when (challengeStatus) {
+                ChallengeStatus.COMPLETED -> "completed"
+                ChallengeStatus.FAILED -> "failed"
+                ChallengeStatus.ACTIVE -> {
+                    // Challenge is still active, check if player died (spectator mode)
+                    if (savedGameMode == "SPECTATOR") "failed" else "active"
+                }
+            }
+        }
+
+        return "not_joined"
+    }
 }

src/main/kotlin/li/angu/challengeplugin/managers/ChallengeMenuManager.kt

@@ -5,6 +5,7 @@ import li.angu.challengeplugin.models.Challenge
 import li.angu.challengeplugin.models.ChallengeStatus
 import org.bukkit.Bukkit
 import org.bukkit.Material
+import org.bukkit.NamespacedKey
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.HandlerList
@@ -14,13 +15,15 @@ import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.ItemMeta
+import org.bukkit.persistence.PersistentDataType
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 
 class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener {
 
     private val playerMenus = ConcurrentHashMap<UUID, Inventory>()
-    private val challengesPerInventory = ConcurrentHashMap<Inventory, List<Challenge>>()
+    private val challengesPerInventory = ConcurrentHashMap<Inventory, List<ChallengeMenuData>>()
+    private val filterToggleKey = NamespacedKey(plugin, "filter_show_all")
 
     init {
         plugin.server.pluginManager.registerEvents(this, plugin)
@@ -32,7 +35,7 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
         challengesPerInventory.clear()
     }
 
-    fun openMainMenu(player: Player) {
+    fun openMainMenu(player: Player, showAll: Boolean = false) {
         val inventory = Bukkit.createInventory(
             player,
             54, // 6 rows
@@ -56,7 +59,11 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
         createMeta.setDisplayName(plugin.languageManager.getMessage("challenge.menu.create", player))
         createMeta.lore = listOf(plugin.languageManager.getMessage("challenge.menu.create_lore", player))
         createItem.itemMeta = createMeta
-        inventory.setItem(4, createItem)
+        inventory.setItem(0, createItem)
+        
+        // Filter toggle button (slot 4)
+        val filterItem = createFilterToggleItem(player, showAll)
+        inventory.setItem(4, filterItem)
 
         // Create Leave Challenge button
         val leaveItem = ItemStack(Material.BARRIER)
@@ -66,24 +73,24 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
         leaveItem.itemMeta = leaveMeta
         inventory.setItem(8, leaveItem)
 
-        // Get all active challenges
-        val challenges = plugin.challengeManager.getActiveChallenges()
+        // Get challenges using efficient database query
+        val challenges = plugin.challengeManager.getChallengesForMenu(player.uniqueId, showAll)
         val playerCurrentChallenge = plugin.challengeManager.getPlayerChallenge(player)
 
         // Store the challenges for this inventory so we can retrieve them in the click handler
         challengesPerInventory[inventory] = challenges
 
         // Add challenges to inventory
         if (challenges.isNotEmpty()) {
-            challenges.forEachIndexed { index, challenge ->
+            challenges.forEachIndexed { index, challengeData ->
                 // Start at slot 18 (third row) and fill rows from there
                 val slot = 18 + index
 
                 // Skip if we've reached the end of the inventory
                 if (slot >= inventory.size) return@forEachIndexed
 
-                val isCurrentChallenge = playerCurrentChallenge?.id == challenge.id
-                val challengeItem = createChallengeItem(challenge, player, isCurrentChallenge)
+                val isCurrentChallenge = playerCurrentChallenge?.id == challengeData.id
+                val challengeItem = createChallengeItemFromData(challengeData, player, isCurrentChallenge)
                 inventory.setItem(slot, challengeItem)
             }
         } else {
@@ -102,43 +109,63 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
         player.openInventory(inventory)
     }
 
-    private fun createChallengeItem(challenge: Challenge, player: Player, isCurrentChallenge: Boolean): ItemStack {
-        // Choose material based on whether this is the player's current challenge
-        val material = when {
-            isCurrentChallenge -> Material.ENCHANTED_BOOK
-            else -> Material.BOOK
+    private fun createFilterToggleItem(player: Player, showAll: Boolean): ItemStack {
+        val item = ItemStack(Material.PLAYER_HEAD)
+        val meta = item.itemMeta ?: Bukkit.getItemFactory().getItemMeta(Material.PLAYER_HEAD)
+        
+        // Store filter state in persistent data
+        meta.persistentDataContainer.set(filterToggleKey, PersistentDataType.BYTE, if (showAll) 1 else 0)
+        
+        if (showAll) {
+            meta.setDisplayName(plugin.languageManager.getMessage("challenge.menu.filter_all", player))
+            meta.lore = listOf(plugin.languageManager.getMessage("challenge.menu.filter_all_lore", player))
+        } else {
+            meta.setDisplayName(plugin.languageManager.getMessage("challenge.menu.filter_your", player))
+            meta.lore = listOf(plugin.languageManager.getMessage("challenge.menu.filter_your_lore", player))
+            
+            // Set to player's head
+            if (meta is org.bukkit.inventory.meta.SkullMeta) {
+                meta.owningPlayer = player
+            }
         }
 
+        item.itemMeta = meta
+        return item
+    }
+    
+    private fun createChallengeItemFromData(challengeData: ChallengeMenuData, player: Player, isCurrentChallenge: Boolean): ItemStack {
+        val material = if (isCurrentChallenge) Material.ENCHANTED_BOOK else Material.BOOK
+        
         val item = ItemStack(material)
         val meta = item.itemMeta ?: Bukkit.getItemFactory().getItemMeta(material)
 
         meta.setDisplayName(
             if (isCurrentChallenge) 
-                plugin.languageManager.getMessage("challenge.menu.current_challenge", player, "name" to challenge.name)
+                plugin.languageManager.getMessage("challenge.menu.current_challenge", player, "name" to challengeData.name)
             else 
-                plugin.languageManager.getMessage("challenge.menu.challenge", player, "name" to challenge.name)
+                plugin.languageManager.getMessage("challenge.menu.challenge", player, "name" to challengeData.name)
         )
 
         val loreList = mutableListOf<String>()
 
         // Challenge ID
-        loreList.add(plugin.languageManager.getMessage("challenge.menu.id", player, "id" to challenge.id.toString()))
-        
-        // Challenge status
-        val statusKey = when(challenge.status) {
-            ChallengeStatus.ACTIVE -> "status.active"
-            ChallengeStatus.COMPLETED -> "status.completed"
-            ChallengeStatus.FAILED -> "status.failed"
-        }
-        loreList.add(plugin.languageManager.getMessage("challenge.menu.status", player, 
-            "status" to plugin.languageManager.getMessage(statusKey, player)))
+        loreList.add(plugin.languageManager.getMessage("challenge.menu.id", player, "id" to challengeData.id.toString()))
 
         // Players
-        loreList.add(plugin.languageManager.getMessage("challenge.menu.players", player, "count" to challenge.players.size.toString()))
+        loreList.add(plugin.languageManager.getMessage("challenge.menu.players", player, "count" to challengeData.playerCount.toString()))
+        
+        // Player status for this challenge
+        val playerStatusMessage = when(challengeData.playerStatus) {
+            "active" -> plugin.languageManager.getMessage("player_status.active", player)
+            "failed" -> plugin.languageManager.getMessage("player_status.failed", player)
+            "completed" -> plugin.languageManager.getMessage("player_status.completed", player)
+            else -> plugin.languageManager.getMessage("player_status.not_joined", player)
+        }
+        loreList.add(plugin.languageManager.getMessage("challenge.menu.your_status", player, "status" to playerStatusMessage))
 
         // Duration (if started)
-        if (challenge.startedAt != null) {
-            loreList.add(plugin.languageManager.getMessage("challenge.menu.duration", player, "time" to challenge.getFormattedDuration()))
+        if (challengeData.startedAt != null) {
+            loreList.add(plugin.languageManager.getMessage("challenge.menu.duration", player, "time" to challengeData.getFormattedDuration()))
         }
 
         // Action text
@@ -155,6 +182,7 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
         return item
     }
 
+    
     @EventHandler
     fun onInventoryClick(event: InventoryClickEvent) {
         val player = event.whoClicked as? Player ?: return
@@ -171,11 +199,21 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
 
         when (event.slot) {
             // Create Challenge button
-            4 -> {
+            0 -> {
                 player.closeInventory()
                 player.performCommand("create ") // Open create name prompt
             }
 
+            // Filter Toggle button
+            4 -> {
+                val filterItem = event.currentItem ?: return
+                val currentShowAll = filterItem.itemMeta?.persistentDataContainer?.get(filterToggleKey, PersistentDataType.BYTE) == 1.toByte()
+                
+                // Toggle filter and refresh menu
+                player.closeInventory()
+                openMainMenu(player, !currentShowAll)
+            }
+            
             // Leave Challenge button
             8 -> {
                 val currentChallenge = plugin.challengeManager.getPlayerChallenge(player)
@@ -202,15 +240,15 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
                 // Calculate index in the challenges list
                 val index = event.slot - 18
                 if (index >= 0 && index < challenges.size) {
-                    val challenge = challenges[index]
+                    val challengeData = challenges[index]
                     val currentChallenge = plugin.challengeManager.getPlayerChallenge(player)
 
-                    if (currentChallenge?.id == challenge.id) {
+                    if (currentChallenge?.id == challengeData.id) {
                         // Player clicked their current challenge, leave it
-                        plugin.playerDataManager.savePlayerData(player, challenge.id)
+                        plugin.playerDataManager.savePlayerData(player, challengeData.id)
 
                         if (plugin.challengeManager.leaveChallenge(player)) {
-                            player.sendMessage(plugin.languageManager.getMessage("challenge.left", player, "name" to challenge.name))
+                            player.sendMessage(plugin.languageManager.getMessage("challenge.left", player, "name" to challengeData.name))
 
                             // Refresh the menu
                             player.closeInventory()
@@ -220,13 +258,15 @@ class ChallengeMenuManager(private val plugin: ChallengePluginPlugin) : Listener
                         }
                     } else {
                         // Player clicked a different challenge, join it
-                        if (challenge.status != ChallengeStatus.ACTIVE) {
+                        if (challengeData.status != ChallengeStatus.ACTIVE) {
                             player.sendMessage(plugin.languageManager.getMessage("challenge.already_completed", player))
                             return
                         }
 
-                        if (plugin.challengeManager.joinChallenge(player, challenge)) {
-                            player.sendMessage(plugin.languageManager.getMessage("challenge.joined", player, "name" to challenge.name))
+                        // Get full challenge object from memory to join
+                        val fullChallenge = plugin.challengeManager.getChallenge(challengeData.id)
+                        if (fullChallenge != null && plugin.challengeManager.joinChallenge(player, fullChallenge)) {
+                            player.sendMessage(plugin.languageManager.getMessage("challenge.joined", player, "name" to challengeData.name))
 
                             // Close the menu
                             player.closeInventory()