fix(commands): fix /guild info and /guild members fallback for players without guilds

src/main/java/fr/luc/gamingcore/command/GuildCommands.java

@@ -12,7 +12,6 @@ import fr.luc.gamingcore.util.MessageManager;
 import fr.luc.gamingcore.util.TextUtil;
 import org.bukkit.Chunk;
 import org.bukkit.Location;
-import org.bukkit.World;
 import org.bukkit.entity.Player;
 
 import java.time.Duration;
@@ -123,14 +122,14 @@ public class GuildCommands {
                             return ValidationResult.valid();
                         })
 
-                        // Confirmation préalable avec rappel
                         .requireConfirmation(Duration.ofSeconds(20))
 
                         .executes(context -> {
                             Player player = context.getPlayer();
                             String name = context.getString("nom");
                             Optional<String> tagOpt = context.getOptional("tag", String.class);
-                            String tag = tagOpt.orElse(name.length() <= 4 ? name.toUpperCase() : name.substring(0, 4).toUpperCase());
+                            String tag = tagOpt.filter(s -> !s.trim().isEmpty())
+                                    .orElse(name.length() <= 4 ? name.toUpperCase() : name.substring(0, 4).toUpperCase());
 
                             Location loc = player.getLocation();
                             Chunk chunk = loc.getChunk();
@@ -159,15 +158,19 @@ public class GuildCommands {
                         .description("Dissoudre définitivement votre guilde")
                         .aliases("delete", "supprimer")
                         .playerOnly()
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            if (g == null) return false;
+                            if (g == null) return ValidationResult.invalid(msg.get("guild.not_in_guild"));
                             GuildRank leaderRank = g.getLeaderRank();
                             GuildMember member = g.getMember(context.getPlayer().getUniqueId());
-                            return member != null && leaderRank != null && member.getRankId().equalsIgnoreCase(leaderRank.getId());
+                            if (member == null || leaderRank == null || !member.getRankId().equalsIgnoreCase(leaderRank.getId())) {
-                        }, msg.get("guild.disband.not_leader"))
+                                return ValidationResult.invalid(msg.get("guild.disband.not_leader"));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .requireConfirmation(Duration.ofSeconds(15))
                         .executes(context -> {
                             Player player = context.getPlayer();
@@ -191,16 +194,23 @@ public class GuildCommands {
                         .description("Inviter un joueur connecté à rejoindre votre guilde")
                         .playerOnly()
                         .argument(Arguments.player("joueur").description("Joueur cible"))
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            return g != null && g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.INVITE);
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.INVITE)) {
-                        }, msg.get("guild.invite.no_permission"))
+                                return ValidationResult.invalid(msg.get("guild.invite.no_permission"));
-                        .validate(context -> !context.getTargetPlayer("joueur").getUniqueId().equals(context.getPlayer().getUniqueId()),
+                            }
-                                msg.get("guild.invite.cannot_invite_self"))
+                            Player target = context.getTargetPlayer("joueur");
-                        .validate(context -> !guildManager.isInGuild(context.getTargetPlayer("joueur").getUniqueId()),
+                            if (target.getUniqueId().equals(context.getPlayer().getUniqueId())) {
-                                msg.get("guild.invite.target_already_in_guild", "{player}", ""))
+                                return ValidationResult.invalid(msg.get("guild.invite.cannot_invite_self"));
+                            }
+                            if (guildManager.isInGuild(target.getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.invite.target_already_in_guild", "{player}", target.getName()));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player sender = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(sender.getUniqueId());
@@ -227,8 +237,12 @@ public class GuildCommands {
                         .aliases("accept", "rejoindre")
                         .playerOnly()
                         .argument(Arguments.string("guilde").description("Nom de la guilde"))
-                        .validate(context -> !guildManager.isInGuild(context.getPlayer().getUniqueId()),
+                        .validate(context -> {
-                                msg.get("guild.already_in_guild"))
+                            if (guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.already_in_guild"));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             String guildName = context.getString("guilde");
@@ -262,8 +276,20 @@ public class GuildCommands {
                         .description("Quitter votre guilde actuelle")
                         .aliases("quitter")
                         .playerOnly()
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
+                        .validate(context -> {
-                                msg.get("guild.not_in_guild"))
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
+                            Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
+                            if (g != null) {
+                                GuildRank leaderRank = g.getLeaderRank();
+                                GuildMember member = g.getMember(context.getPlayer().getUniqueId());
+                                if (leaderRank != null && member != null && member.getRankId().equalsIgnoreCase(leaderRank.getId())) {
+                                    return ValidationResult.invalid(msg.get("guild.leave.leader_cannot_leave"));
+                                }
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -286,8 +312,28 @@ public class GuildCommands {
                         .description("Expulser un membre de votre guilde")
                         .playerOnly()
                         .argument(Arguments.player("joueur").description("Joueur à expulser"))
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
+                        .validate(context -> {
-                                msg.get("guild.not_in_guild"))
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
+                            Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.KICK)) {
+                                return ValidationResult.invalid(msg.get("guild.kick.no_permission"));
+                            }
+                            Player target = context.getTargetPlayer("joueur");
+                            if (target.getUniqueId().equals(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.kick.cannot_kick_self"));
+                            }
+                            if (!g.isMember(target.getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_member"));
+                            }
+                            GuildRank actorRank = g.getMemberRank(context.getPlayer().getUniqueId());
+                            GuildRank targetRank = g.getMemberRank(target.getUniqueId());
+                            if (actorRank != null && targetRank != null && targetRank.getPriority() >= actorRank.getPriority()) {
+                                return ValidationResult.invalid(msg.get("guild.kick.insufficient_rank"));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -310,16 +356,27 @@ public class GuildCommands {
                 .subcommand(BetterMcCommands.subBuilder("claim")
                         .description("Revendiquer le chunk actuel pour votre guilde")
                         .playerOnly()
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            return g != null && g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.CLAIM);
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.CLAIM)) {
-                        }, msg.get("guild.claim.no_permission"))
+                                return ValidationResult.invalid(msg.get("guild.claim.no_permission"));
-                        .validate(context -> {
+                            }
                             Chunk chunk = context.getPlayer().getLocation().getChunk();
-                            return !guildManager.isChunkClaimed(chunk.getWorld().getName(), chunk.getX(), chunk.getZ());
+                            if (guildManager.isChunkClaimed(chunk.getWorld().getName(), chunk.getX(), chunk.getZ())) {
-                        }, msg.get("guild.claim.already_claimed"))
+                                return ValidationResult.invalid(msg.get("guild.claim.already_claimed"));
+                            }
+                            double price = guildManager.getPriceCalculator().calculateNextChunkPrice(g);
+                            if (!g.hasBalance(price)) {
+                                return ValidationResult.invalid(msg.get("guild.claim.insufficient_bank",
+                                        "{cost}", guildManager.getEconomyManager().format(price),
+                                        "{balance}", guildManager.getEconomyManager().format(g.getBalance())
+                                ));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -346,12 +403,23 @@ public class GuildCommands {
                 .subcommand(BetterMcCommands.subBuilder("unclaim")
                         .description("Libérer le chunk actuel")
                         .playerOnly()
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            return g != null && g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.UNCLAIM);
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.UNCLAIM)) {
-                        }, msg.get("guild.claim.unclaim_no_permission"))
+                                return ValidationResult.invalid(msg.get("guild.claim.unclaim_no_permission"));
+                            }
+                            Chunk chunk = context.getPlayer().getLocation().getChunk();
+                            if (!g.isClaimed(chunk.getWorld().getName(), chunk.getX(), chunk.getZ())) {
+                                return ValidationResult.invalid(msg.get("guild.claim.unclaim_not_owned"));
+                            }
+                            if (g.getClaimCount() <= 1) {
+                                return ValidationResult.invalid(msg.get("guild.claim.unclaim_last_chunk"));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -375,8 +443,20 @@ public class GuildCommands {
                         .aliases("deposer", "don")
                         .playerOnly()
                         .argument(Arguments.decimal("montant", 1.0, 1000000000.0).description("Somme à déposer"))
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
+                        .validate(context -> {
-                                msg.get("guild.not_in_guild"))
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
+                            Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.BANK_DEPOSIT)) {
+                                return ValidationResult.invalid(msg.get("guild.bank.deposit_no_permission"));
+                            }
+                            double amount = context.getDouble("montant");
+                            if (!guildManager.getEconomyManager().has(context.getPlayer(), amount)) {
+                                return ValidationResult.invalid(msg.get("guild.bank.deposit_insufficient_player"));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -402,8 +482,22 @@ public class GuildCommands {
                         .aliases("retirer")
                         .playerOnly()
                         .argument(Arguments.decimal("montant", 1.0, 1000000000.0).description("Somme à retirer"))
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
+                        .validate(context -> {
-                                msg.get("guild.not_in_guild"))
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
+                            Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.BANK_WITHDRAW)) {
+                                return ValidationResult.invalid(msg.get("guild.bank.withdraw_no_permission"));
+                            }
+                            double amount = context.getDouble("montant");
+                            if (!g.hasBalance(amount)) {
+                                return ValidationResult.invalid(msg.get("guild.bank.withdraw_insufficient_bank",
+                                        "{balance}", guildManager.getEconomyManager().format(g.getBalance())
+                                ));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -426,22 +520,24 @@ public class GuildCommands {
                 .subcommand(BetterMcCommands.subBuilder("sethome")
                         .description("Définir le home de guilde à votre position")
                         .playerOnly()
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            return g != null && g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.SET_HOME);
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.SET_HOME)) {
-                        }, msg.get("guild.home.set_no_permission"))
+                                return ValidationResult.invalid(msg.get("guild.home.set_no_permission"));
+                            }
+                            Location loc = context.getPlayer().getLocation();
+                            if (!g.isClaimed(loc.getWorld().getName(), loc.getBlockX() >> 4, loc.getBlockZ() >> 4)) {
+                                return ValidationResult.invalid(msg.get("guild.home.set_must_be_in_claim"));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
                             Location loc = player.getLocation();
-                            Chunk chunk = loc.getChunk();
-
-                            if (!guild.isClaimed(loc.getWorld().getName(), chunk.getX(), chunk.getZ())) {
-                                context.reply(msg.get("guild.home.set_must_be_in_claim"));
-                                return;
-                            }
 
                             guild.setHome(loc);
                             plugin.getGuildRepository().saveGuildAsync(guild);
@@ -455,22 +551,24 @@ public class GuildCommands {
                 .subcommand(BetterMcCommands.subBuilder("home")
                         .description("Se téléporter au point de ralliement de la guilde")
                         .playerOnly()
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            return g != null && g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.HOME);
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.HOME)) {
-                        }, msg.get("guild.home.teleport_no_permission"))
+                                return ValidationResult.invalid(msg.get("guild.home.teleport_no_permission"));
+                            }
+                            if (g.getHomeLocation() == null) {
+                                return ValidationResult.invalid(msg.get("guild.home.not_set"));
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
                             Location homeLoc = guild.getHomeLocation();
 
-                            if (homeLoc == null) {
-                                context.reply(msg.get("guild.home.not_set"));
-                                return;
-                            }
-
                             player.teleportAsync(homeLoc).thenAccept(success -> {
                                 if (success) {
                                     msg.sendActionBar(player, "guild.home.teleport_success");
@@ -479,43 +577,6 @@ public class GuildCommands {
                         })
                 )
 
-                // -------------------------------------------------------------
-                // Sous-commande : /guild info [guilde]
-                // -------------------------------------------------------------
-                .subcommand(BetterMcCommands.subBuilder("info")
-                        .description("Afficher les informations d'une guilde")
-                        .argument(Arguments.string("guilde").optional().description("Nom de la guilde"))
-                        .executes(context -> {
-                            Guild targetGuild;
-                            Optional<String> nameOpt = context.getOptional("guilde", String.class);
-                            if (nameOpt.isPresent()) {
-                                targetGuild = guildManager.getGuildByName(nameOpt.get());
-                            } else if (context.isPlayer()) {
-                                targetGuild = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            } else {
-                                context.replyError("Veuillez préciser le nom de la guilde.");
-                                return;
-                            }
-
-                            if (targetGuild == null) {
-                                context.reply(msg.get("guild.guild_not_found", "{guild}", nameOpt.orElse("")));
-                                return;
-                            }
-
-                            double nextPrice = guildManager.getPriceCalculator().calculateNextChunkPrice(targetGuild);
-                            GuildMember leader = targetGuild.getLeaderMember();
-                            String leaderName = leader != null && leader.getOfflinePlayer() != null ? leader.getOfflinePlayer().getName() : "Inconnu";
-
-                            context.reply("<gradient:#00C9FF:#92FE9D><bold>=== INFORMATIONS DE GUILDE ===</bold></gradient>");
-                            context.reply("<gray>Nom :</gray> " + targetGuild.getFormattedName() + " " + targetGuild.getFormattedTag());
-                            context.reply("<gray>Couleur :</gray> <color:" + targetGuild.getColor() + ">" + targetGuild.getColor() + " ■</color>");
-                            context.reply("<gray>Chef :</gray> <gold>" + leaderName + "</gold>");
-                            context.reply("<gray>Membres :</gray> <yellow>" + targetGuild.getMemberCount() + "</yellow>");
-                            context.reply("<gray>Banque :</gray> <green>" + guildManager.getEconomyManager().format(targetGuild.getBalance()) + "</green>");
-                            context.reply("<gray>Territoires :</gray> <aqua>" + targetGuild.getClaimCount() + " chunks</aqua> <dark_gray>(Prochain: " + guildManager.getEconomyManager().format(nextPrice) + ")</dark_gray>");
-                        })
-                )
-
                 // -------------------------------------------------------------
                 // Sous-commande : /guild color <#hex>
                 // -------------------------------------------------------------
@@ -524,14 +585,19 @@ public class GuildCommands {
                         .aliases("couleur")
                         .playerOnly()
                         .argument(Arguments.string("hex").description("Code couleur hexadécimal (ex: #FF5555)"))
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            return g != null && g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.MANAGE_GUILD);
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.MANAGE_GUILD)) {
-                        }, "<red>Votre rang ne vous autorise pas à modifier les informations de la guilde.</red>")
+                                return ValidationResult.invalid("<red>Votre rang ne vous autorise pas à modifier les informations de la guilde.</red>");
-                        .validate(context -> context.getString("hex").matches("^#[0-9a-fA-F]{6}$"),
+                            }
-                                "<red>Format de couleur invalide ! Utilisez un code hexadécimal à 6 caractères (ex: <yellow>#00FFAA</yellow> ou <yellow>#FF5555</yellow>).</red>")
+                            if (!context.getString("hex").matches("^#[0-9a-fA-F]{6}$")) {
+                                return ValidationResult.invalid("<red>Format de couleur invalide ! Utilisez un code hexadécimal à 6 caractères (ex: <yellow>#00FFAA</yellow> ou <yellow>#FF5555</yellow>).</red>");
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -553,14 +619,19 @@ public class GuildCommands {
                         .description("Changer le tag court de votre guilde")
                         .playerOnly()
                         .argument(Arguments.string("tag").description("Nouveau tag (2-6 car)"))
-                        .validate(context -> guildManager.isInGuild(context.getPlayer().getUniqueId()),
-                                msg.get("guild.not_in_guild"))
                         .validate(context -> {
+                            if (!guildManager.isInGuild(context.getPlayer().getUniqueId())) {
+                                return ValidationResult.invalid(msg.get("guild.not_in_guild"));
+                            }
                             Guild g = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
-                            return g != null && g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.MANAGE_GUILD);
+                            if (g == null || !g.hasPermission(context.getPlayer().getUniqueId(), GuildPermission.MANAGE_GUILD)) {
-                        }, "<red>Votre rang ne vous autorise pas à modifier les informations de la guilde.</red>")
+                                return ValidationResult.invalid("<red>Votre rang ne vous autorise pas à modifier les informations de la guilde.</red>");
-                        .validate(context -> context.getString("tag").matches("^[a-zA-Z0-9_]{2,6}$"),
+                            }
-                                "<red>Le tag doit comporter entre 2 et 6 caractères alphanumériques.</red>")
+                            if (!context.getString("tag").matches("^[a-zA-Z0-9_]{2,6}$")) {
+                                return ValidationResult.invalid("<red>Le tag doit comporter entre 2 et 6 caractères alphanumériques.</red>");
+                            }
+                            return ValidationResult.valid();
+                        })
                         .executes(context -> {
                             Player player = context.getPlayer();
                             Guild guild = guildManager.getGuildByPlayer(player.getUniqueId());
@@ -575,6 +646,48 @@ public class GuildCommands {
                         })
                 )
 
+                // -------------------------------------------------------------
+                // Sous-commande : /guild info [guilde]
+                // -------------------------------------------------------------
+                .subcommand(BetterMcCommands.subBuilder("info")
+                        .description("Afficher les informations d'une guilde")
+                        .argument(Arguments.string("guilde").optional().description("Nom de la guilde"))
+                        .executes(context -> {
+                            Guild targetGuild;
+                            Optional<String> nameOpt = context.getOptional("guilde", String.class);
+                            String inputName = nameOpt.orElse(null);
+
+                            if (inputName != null && !inputName.trim().isEmpty()) {
+                                targetGuild = guildManager.getGuildByName(inputName.trim());
+                                if (targetGuild == null) {
+                                    context.reply(msg.get("guild.guild_not_found", "{guild}", inputName.trim()));
+                                    return;
+                                }
+                            } else if (context.isPlayer()) {
+                                targetGuild = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
+                                if (targetGuild == null) {
+                                    context.reply(msg.get("guild.not_in_guild"));
+                                    return;
+                                }
+                            } else {
+                                context.replyError("Veuillez préciser le nom de la guilde : /guild info <guilde>");
+                                return;
+                            }
+
+                            double nextPrice = guildManager.getPriceCalculator().calculateNextChunkPrice(targetGuild);
+                            GuildMember leader = targetGuild.getLeaderMember();
+                            String leaderName = leader != null && leader.getOfflinePlayer() != null ? leader.getOfflinePlayer().getName() : "Inconnu";
+
+                            context.reply("<gradient:#00C9FF:#92FE9D><bold>=== INFORMATIONS DE GUILDE ===</bold></gradient>");
+                            context.reply("<gray>Nom :</gray> " + targetGuild.getFormattedName() + " " + targetGuild.getFormattedTag());
+                            context.reply("<gray>Couleur :</gray> <color:" + targetGuild.getColor() + ">" + targetGuild.getColor() + " ■</color>");
+                            context.reply("<gray>Chef :</gray> <gold>" + leaderName + "</gold>");
+                            context.reply("<gray>Membres :</gray> <yellow>" + targetGuild.getMemberCount() + "</yellow>");
+                            context.reply("<gray>Banque :</gray> <green>" + guildManager.getEconomyManager().format(targetGuild.getBalance()) + "</green>");
+                            context.reply("<gray>Territoires :</gray> <aqua>" + targetGuild.getClaimCount() + " chunks</aqua> <dark_gray>(Prochain: " + guildManager.getEconomyManager().format(nextPrice) + ")</dark_gray>");
+                        })
+                )
+
                 // -------------------------------------------------------------
                 // Sous-commande : /guild members [guilde]
                 // -------------------------------------------------------------
@@ -584,17 +697,22 @@ public class GuildCommands {
                         .executes(context -> {
                             Guild targetGuild;
                             Optional<String> nameOpt = context.getOptional("guilde", String.class);
-                            if (nameOpt.isPresent()) {
+                            String inputName = nameOpt.orElse(null);
-                                targetGuild = guildManager.getGuildByName(nameOpt.get());
+
-                            } else if (context.isPlayer()) {
+                            if (inputName != null && !inputName.trim().isEmpty()) {
-                                targetGuild = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
+                                targetGuild = guildManager.getGuildByName(inputName.trim());
-                            } else {
+                                if (targetGuild == null) {
-                                context.replyError("Veuillez préciser le nom de la guilde.");
+                                    context.reply(msg.get("guild.guild_not_found", "{guild}", inputName.trim()));
                                     return;
                                 }
-
+                            } else if (context.isPlayer()) {
+                                targetGuild = guildManager.getGuildByPlayer(context.getPlayer().getUniqueId());
                                 if (targetGuild == null) {
-                                context.reply(msg.get("guild.guild_not_found", "{guild}", nameOpt.orElse("")));
+                                    context.reply(msg.get("guild.not_in_guild"));
+                                    return;
+                                }
+                            } else {
+                                context.replyError("Veuillez préciser le nom de la guilde : /guild members <guilde>");
                                 return;
                             }