code refactoring

src/main/java/me/unurled/sacredrealms/sr/commands/admin/AttributeCommand.java

@@ -10,6 +10,7 @@ import me.unurled.sacredrealms.sr.components.attributes.Attribute;
 import me.unurled.sacredrealms.sr.components.player.PlayerManager;
 import me.unurled.sacredrealms.sr.components.player.SRPlayer;
 import me.unurled.sacredrealms.sr.gui.attributes.AttributesGUI;
+import me.unurled.sacredrealms.sr.managers.Manager;
 import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
@@ -26,7 +27,7 @@ public class AttributeCommand implements TabExecutor {
 
   @Nullable
   private static SRPlayer getSrPlayer(@NotNull CommandSender sender, Player target) {
-    PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
+    PlayerManager pm = Manager.getInstance(PlayerManager.class);
     if (pm == null) {
       sender.sendMessage(comp("<red>An error occurred."));
       return null;
@@ -39,21 +40,20 @@ public class AttributeCommand implements TabExecutor {
     return player;
   }
 
-  private static boolean remove(@NotNull CommandSender sender, Player target, Attribute attribute) {
+  private static void remove(@NotNull CommandSender sender, Player target, Attribute attribute) {
     SRPlayer player = getSrPlayer(sender, target);
-    if (player == null) return true;
+    if (player == null) return;
     player.removeAttribute(attribute);
     player.removeItemAttributes(attribute, target.getInventory().getItemInMainHand());
     syncSRToPlayer(player, target);
     sender.sendMessage("Removed " + attribute.getName() + FOR + target.getName());
-    PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
+    PlayerManager pm = Manager.getInstance(PlayerManager.class);
     pm.savePlayer(player);
-    return false;
   }
 
-  private static boolean get(@NotNull CommandSender sender, Player target, Attribute attribute) {
+  private static void get(@NotNull CommandSender sender, Player target, Attribute attribute) {
     SRPlayer player = getSrPlayer(sender, target);
-    if (player == null) return true;
+    if (player == null) return;
     sender.sendMessage(
         "Get "
             + attribute.getName()
@@ -61,10 +61,9 @@ public class AttributeCommand implements TabExecutor {
             + target.getName()
             + ": "
             + player.getAttribute(attribute));
-    return false;
   }
 
-  private static boolean set(
+  private static void set(
       @NotNull CommandSender sender,
       @NotNull String @NotNull [] args,
       Attribute attribute,
@@ -77,40 +76,38 @@ public class AttributeCommand implements TabExecutor {
                 + attribute.getMinValue()
                 + ", Max: "
                 + attribute.getMaxValue());
-        return true;
+        return;
       }
       SRPlayer player = getSrPlayer(sender, target);
-      if (player == null) return true;
+      if (player == null) return;
       player.setAttribute(attribute, value);
       sender.sendMessage("Set " + attribute.getName() + " to " + value + FOR + target.getName());
       player.setItemAttributes(attribute, target.getInventory().getItemInMainHand(), value);
       syncSRToPlayer(player, target);
-      PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
+      PlayerManager pm = Manager.getInstance(PlayerManager.class);
       pm.savePlayer(player);
     } catch (NumberFormatException e) {
       sender.sendMessage("Invalid value.");
     }
-    return false;
   }
 
-  private static boolean itemInHand(
-      @NotNull CommandSender sender, @NotNull String @NotNull [] args) {
+  private static void itemInHand(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
     if (!(sender instanceof Player target)) {
       sender.sendMessage("You must be a player to use this command.");
-      return true;
+      return;
     }
     Attribute attribute;
     try {
       attribute = Attribute.valueOf(args[2].toUpperCase());
     } catch (IllegalArgumentException e) {
       sender.sendMessage("Attribute not found.");
-      return true;
+      return;
     }
 
     if (args[0].equalsIgnoreCase("set")) {
       try {
         Result result = getResult(sender, args, target, attribute);
-        if (result == null) return true;
+        if (result == null) return;
         result.player().setHandItemAttribute(attribute, result.value());
         sender.sendMessage(
             "Set " + attribute.getName() + " to " + result.value() + FOR + target.getName());
@@ -125,7 +122,7 @@ public class AttributeCommand implements TabExecutor {
       }
     } else if (args[0].equalsIgnoreCase("get")) {
       SRPlayer player = getSrPlayer(sender, target);
-      if (player == null) return true;
+      if (player == null) return;
       sender.sendMessage(
           "Get "
               + attribute.getName()
@@ -136,7 +133,7 @@ public class AttributeCommand implements TabExecutor {
               + player.getHandItemAttribute(attribute));
     } else if (args[0].equalsIgnoreCase(REMOVE)) {
       SRPlayer player = getSrPlayer(sender, target);
-      if (player == null) return true;
+      if (player == null) return;
       player.removeHandItemAttribute(attribute);
       player.removeItemAttributes(attribute, target.getInventory().getItemInMainHand());
 
@@ -144,23 +141,22 @@ public class AttributeCommand implements TabExecutor {
     } else {
       sender.sendMessage("Usage: /attribute <set|get|remove> <player> <attribute> [value]");
     }
-    return true;
   }
 
-  private static boolean gui(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
+  private static void gui(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
     // open gui
     if (args.length != 2) {
       sender.sendMessage("Usage: /attribute gui <player>");
-      return true;
+      return;
     }
     if (!(sender instanceof Player p)) {
       sender.sendMessage("You must be a player to use this command.");
-      return true;
+      return;
     }
     Player target = Bukkit.getPlayer(args[1]);
     if (target == null) {
       sender.sendMessage("Player not found.");
-      return true;
+      return;
     }
     Window window =
         Window.single()
@@ -169,8 +165,6 @@ public class AttributeCommand implements TabExecutor {
             .setGui(AttributesGUI.createGui(target))
             .build();
     window.open();
-
-    return true;
   }
 
   @Nullable
@@ -225,10 +219,12 @@ public class AttributeCommand implements TabExecutor {
       return true;
     }
     if (args[0].equals("gui")) {
-      return gui(sender, args);
+      gui(sender, args);
+      return true;
     }
     if (args[1].equals("item-in-hand")) {
-      return itemInHand(sender, args);
+      itemInHand(sender, args);
+      return true;
     }
     Player target = Bukkit.getPlayer(args[1]);
     if (target == null) {
@@ -244,13 +240,16 @@ public class AttributeCommand implements TabExecutor {
       return true;
     }
 
-    if (args[0].equalsIgnoreCase("set") && (set(sender, args, attribute, target))) {
+    if (args[0].equalsIgnoreCase("set")) {
+      set(sender, args, attribute, target);
       return true;
     }
-    if (args[0].equalsIgnoreCase("get") && (get(sender, target, attribute))) {
+    if (args[0].equalsIgnoreCase("get")) {
+      get(sender, target, attribute);
       return true;
     }
-    if (args[0].equalsIgnoreCase(REMOVE) && (remove(sender, target, attribute))) {
+    if (args[0].equalsIgnoreCase(REMOVE)) {
+      remove(sender, target, attribute);
       return true;
     }
 

src/main/java/me/unurled/sacredrealms/sr/commands/admin/ClientBuildCommand.java

@@ -218,7 +218,7 @@ public class ClientBuildCommand implements TabExecutor, Listener {
   public void onBlockPlace(@NotNull BlockPlaceEvent e) {
     Player p = e.getPlayer();
     if (manager == null) {
-      manager = ClientBuildManager.getInstance(ClientBuildManager.class);
+      manager = Manager.getInstance(ClientBuildManager.class);
     }
     if (manager.hasTemporaryBlocks(p)) {
       log("block placed " + e.getBlock().getType());
@@ -237,7 +237,7 @@ public class ClientBuildCommand implements TabExecutor, Listener {
   public void onBlockBreak(@NotNull BlockBreakEvent e) {
     Player p = e.getPlayer();
     if (manager == null) {
-      manager = ClientBuildManager.getInstance(ClientBuildManager.class);
+      manager = Manager.getInstance(ClientBuildManager.class);
     }
     if (manager.hasTemporaryBlocks(p)) {
       manager.getTemporaryBlocks(p).remove(e.getBlock().getLocation());
@@ -275,11 +275,10 @@ public class ClientBuildCommand implements TabExecutor, Listener {
             || args[0].equalsIgnoreCase(DISPLAY))) {
       ClientBuildManager clientBuildManager = Manager.getInstance(ClientBuildManager.class);
       List<String> buildNames = clientBuildManager.getBuildNames();
-        if (nameCompletions.isEmpty() || !new HashSet<>(nameCompletions).containsAll(buildNames)) {
-          nameCompletions = buildNames;
-        }
-        return nameCompletions;
-
+      if (nameCompletions.isEmpty() || !new HashSet<>(nameCompletions).containsAll(buildNames)) {
+        nameCompletions = buildNames;
+      }
+      return nameCompletions;
     }
     return null;
   }

src/main/java/me/unurled/sacredrealms/sr/commands/admin/EntityTypeCommand.java

@@ -8,6 +8,7 @@ import java.util.List;
 import me.unurled.sacredrealms.sr.components.entity.EntityManager;
 import me.unurled.sacredrealms.sr.components.entity.SREntityType;
 import me.unurled.sacredrealms.sr.gui.entitytype.EntityTypeGUI;
+import me.unurled.sacredrealms.sr.managers.Manager;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -40,7 +41,7 @@ public class EntityTypeCommand implements TabExecutor {
       return true;
     }
     if (args.length < 3) {
-      EntityManager em = EntityManager.getInstance(EntityManager.class);
+      EntityManager em = Manager.getInstance(EntityManager.class);
       if (!em.getTypes().stream().map(SREntityType::getID).toList().contains(args[1])) {
         sender.sendMessage("Invalid entity type.");
         return true;
@@ -66,7 +67,7 @@ public class EntityTypeCommand implements TabExecutor {
       }
       try {
         EntityType type = EntityType.valueOf(args[4]);
-        EntityManager em = EntityManager.getInstance(EntityManager.class);
+        EntityManager em = Manager.getInstance(EntityManager.class);
         if (setType(sender, args, em, type)) return true;
       } catch (IllegalArgumentException e) {
         sender.sendMessage("Invalid entity type.");
@@ -179,12 +180,12 @@ public class EntityTypeCommand implements TabExecutor {
         return List.of("create", "delete", "edit", "list");
       }
       if (args.length == 2) {
-        return EntityManager.getInstance(EntityManager.class).getTypes().stream()
+        return Manager.getInstance(EntityManager.class).getTypes().stream()
             .map(SREntityType::getID)
             .toList();
       }
       if (args.length == 3 && (args[0].equalsIgnoreCase("edit"))) {
-          return List.of("type", "behavior", "loot", "item", "stats", "name", "level");
+        return List.of("type", "behavior", "loot", "item", "stats", "name", "level");
       }
       if (args.length == 4
           && (args[0].equalsIgnoreCase("edit") && (args[2].equalsIgnoreCase("type")))) {

src/main/java/me/unurled/sacredrealms/sr/commands/admin/ItemCommand.java

@@ -10,6 +10,7 @@ import me.unurled.sacredrealms.sr.components.item.Item;
 import me.unurled.sacredrealms.sr.components.item.ItemManager;
 import me.unurled.sacredrealms.sr.components.item.ItemType;
 import me.unurled.sacredrealms.sr.components.item.Rarity;
+import me.unurled.sacredrealms.sr.managers.Manager;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.command.Command;
@@ -21,6 +22,369 @@ import org.jetbrains.annotations.Nullable;
 
 public class ItemCommand implements TabExecutor {
 
+  public static final String DELETE = "delete";
+  public static final String DOES_NOT_EXIST = "<red>An item with that ID does not exist.";
+  public static final String MODIFY = "modify";
+  public static final String MATERIAL = "material";
+  public static final String ENCHANTMENTS = "enchantments";
+  public static final String ATTRIBUTES = "attributes";
+  public static final String ABILITIES = "abilities";
+  public static final String CUSTOMMODELDATA = "custommodeldata";
+  public static final String RARITY = "rarity";
+  public static final String REMOVE = "remove";
+  public static final String USAGE =
+      "Usage: /item modify <id> <name|material|enchantments|attributes|abilities|custommodeldata|rarity|type|description> [value]";
+
+  private static void modify(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
+    if (args.length < 2) {
+      p.sendMessage(USAGE);
+      return;
+    }
+
+    ItemManager im = Manager.getInstance(ItemManager.class);
+    if (!im.getItemIDs().contains(args[1])) {
+      sender.sendMessage(comp(DOES_NOT_EXIST));
+      return;
+    }
+
+    Item item = im.getItem(args[1]);
+
+    if (args.length == 2) {
+      p.sendMessage(USAGE);
+      return;
+    }
+
+    switch (args[2].toLowerCase()) {
+      case "name" -> modifyName(sender, args, p, item);
+      case MATERIAL -> modifyMaterial(sender, args, p, item);
+      case ENCHANTMENTS -> modifyEnchantments(args, p);
+      case ATTRIBUTES -> modifyAttributes(sender, args, p, item);
+      case ABILITIES -> modifyAbilities(sender, args, p);
+      case CUSTOMMODELDATA -> modifyModelData(sender, args, p, item);
+      case RARITY -> modifyRarity(sender, args, p, item);
+      case "type" -> modifyType(sender, args, p, item);
+      case "description" -> modifyDescription(sender, args, p, item);
+      default -> p.sendMessage(USAGE);
+    }
+  }
+
+  private static void modifyDescription(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> description <value>");
+      return;
+    }
+    String description = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
+    item.setDescription(description);
+    sender.sendMessage(comp("<green>Description set."));
+  }
+
+  private static void modifyType(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> type <value>");
+      return;
+    }
+    ItemType type;
+    try {
+      type = ItemType.valueOf(args[3]);
+    } catch (Exception e) {
+      sender.sendMessage(comp("<red>Type not found."));
+      return;
+    }
+    item.setType(type);
+    sender.sendMessage(comp("<green>Type set."));
+  }
+
+  private static void modifyRarity(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> rarity <value>");
+      return;
+    }
+    Rarity rarity;
+    try {
+      rarity = Rarity.valueOf(args[3]);
+    } catch (Exception e) {
+      sender.sendMessage(comp("<red>Rarity not found."));
+      return;
+    }
+    item.setRarity(rarity);
+    sender.sendMessage(comp("<green>Rarity set."));
+  }
+
+  private static void modifyModelData(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> custommodeldata <value>");
+      return;
+    }
+    int customModelData;
+    try {
+      customModelData = Integer.parseInt(args[3]);
+    } catch (NumberFormatException e) {
+      sender.sendMessage(comp("<red>Invalid value."));
+      return;
+    }
+    item.setCustomModelData(customModelData);
+    sender.sendMessage(comp("<green>Custom model data set."));
+  }
+
+  private static void modifyAbilities(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
+    if (args.length < 5) {
+      p.sendMessage("Usage: /item modify <id> abilities add <ability>");
+      return;
+    }
+    if (args[3].equalsIgnoreCase("add")) {
+      p.sendMessage("Abilities not working for now.");
+      // TODO: add ability
+    } else if (args[3].equalsIgnoreCase(REMOVE)) {
+      sender.sendMessage("Abilities not working for now.");
+      // TODO: remove ability
+    }
+  }
+
+  private static void modifyName(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> name <value>");
+      return;
+    }
+    String name = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
+    item.setName(name);
+    sender.sendMessage(comp("<green>Item name set."));
+    // TODO: update item in player inventory
+  }
+
+  private static void modifyMaterial(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> material <value>");
+      return;
+    }
+    Material material = Material.matchMaterial(args[3]);
+    if (material == null) {
+      sender.sendMessage(comp("<red>Material not found."));
+      return;
+    }
+    item.setMaterial(material);
+    sender.sendMessage(comp("<green>Item material set."));
+  }
+
+  private static void modifyEnchantments(@NotNull String @NotNull [] args, Player p) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> enchantments <add|remove> [enchantment]");
+      return;
+    }
+    if (args[3].equalsIgnoreCase("add")) {
+      if (args.length < 5) {
+        p.sendMessage("Usage: /item modify <id> enchantments add <enchantment>");
+        return;
+      }
+      // TODO: add enchantment
+      p.sendMessage("Enchantments not working for now.");
+      return;
+    }
+    if (args[3].equalsIgnoreCase(REMOVE)) {
+      if (args.length < 5) {
+        p.sendMessage("Usage: /item modify <id> enchantments remove <enchantment>");
+        return;
+      }
+      // TODO: remove enchantment
+      p.sendMessage("Enchantments not working for now.");
+    }
+  }
+
+  private static void modifyAttributes(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
+    if (args.length < 4) {
+      p.sendMessage("Usage: /item modify <id> attributes <add|remove> [attribute] [value]");
+      return;
+    }
+    if (args[3].equalsIgnoreCase("add")) {
+      if (args.length < 6) {
+        p.sendMessage("Usage: /item modify <id> attributes add <attribute> <value>");
+        return;
+      }
+      Attribute attribute = null;
+      try {
+        attribute = Attribute.valueOf(args[4]);
+      } catch (Exception e) {
+        sender.sendMessage(comp("<red>Attribute not found."));
+        error("Error on attribute affectation on item: " + args[1] + "\n" + e);
+        return;
+      }
+      double value;
+      try {
+        value = Double.parseDouble(args[5]);
+      } catch (NumberFormatException e) {
+        sender.sendMessage(comp("<red>Invalid value."));
+        return;
+      }
+      item.addAttribute(attribute, value);
+      sender.sendMessage(comp("<green>Attribute added."));
+      return;
+    }
+    if (args[3].equalsIgnoreCase(REMOVE)) {
+      if (args.length < 5) {
+        p.sendMessage("Usage: /item modify <id> attributes remove <attribute>");
+        return;
+      }
+      Attribute attribute = null;
+      try {
+        attribute = Attribute.valueOf(args[4]);
+      } catch (Exception e) {
+        sender.sendMessage(comp("<red>Attribute not found."));
+        error("Error on attribute affectation on item: " + args[1] + "\n" + e);
+        return;
+      }
+      item.removeAttribute(attribute);
+      sender.sendMessage(comp("<green>Attribute removed."));
+    }
+  }
+
+  private static void give(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
+    if (args.length < 2) {
+      sender.sendMessage("Usage: /item give <id>");
+      return;
+    }
+
+    ItemManager im = Manager.getInstance(ItemManager.class);
+    if (!im.getItemIDs().contains(args[1])) {
+      sender.sendMessage(comp(DOES_NOT_EXIST));
+      return;
+    }
+
+    Item item = im.getItem(args[1]);
+
+    if (args.length == 2) {
+      p.getInventory().addItem(item.toItemStack());
+      sender.sendMessage(comp("<green>Item given."));
+      return;
+    }
+
+    Player target = Bukkit.getPlayer(args[2]);
+    if (target == null) {
+      sender.sendMessage(comp("<red>Player not found."));
+      return;
+    }
+
+    target.getInventory().addItem(item.toItemStack());
+    sender.sendMessage(comp("<green>Item given."));
+  }
+
+  private static void delete(
+      @NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
+    if (args.length < 2) {
+      p.sendMessage("Usage: /item delete <id>");
+      return;
+    }
+    ItemManager im = Manager.getInstance(ItemManager.class);
+    if (!im.getItemIDs().contains(args[1])) {
+      sender.sendMessage(comp(DOES_NOT_EXIST));
+      return;
+    }
+    im.removeItem(args[1]);
+    sender.sendMessage(comp("<green>Item deleted."));
+  }
+
+  private static void create(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
+    if (args.length < 2) {
+      sender.sendMessage("Usage: /item create <id>");
+      return;
+    }
+    ItemManager im = Manager.getInstance(ItemManager.class);
+    if (im.getItemIDs().contains(args[1])) {
+      sender.sendMessage(comp("<red>An item with that ID already exists."));
+      return;
+    }
+    Item item = new Item();
+    item.setID(args[1]);
+    im.addItem(item);
+    sender.sendMessage(
+        comp(
+            "<green>Item created. You can now modify it using "
+                + "<click:suggest_command:/item "
+                + "modify "
+                + args[1]
+                + "> /item modify "
+                + args[1]
+                + "</click>"));
+  }
+
+  private static void list(@NotNull CommandSender sender, Player p) {
+    ItemManager im = Manager.getInstance(ItemManager.class);
+    if (im.getItemIDs().isEmpty()) {
+      sender.sendMessage(comp("<red>There are no items."));
+      return;
+    }
+    sender.sendMessage("Items:");
+    im.getItemIDs().forEach(p::sendMessage);
+  }
+
+  @Nullable
+  private static List<String> modify(@NotNull String @NotNull [] args) {
+    if (args.length == 5 && (args[0].equalsIgnoreCase(MODIFY))) {
+      // TODO: Enchantments in completion
+      /*if (args[2].equalsIgnoreCase("enchantments")) {
+        return Arrays.stream(Enchantment.values()).map(Enum::name).toList();
+      } else*/ if (args[2].equalsIgnoreCase(ATTRIBUTES)) {
+        return Arrays.stream(Attribute.values()).map(Enum::name).toList();
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  private static List<String> modifyCompletion(@NotNull String @NotNull [] args) {
+    if (args.length == 4 && (args[0].equalsIgnoreCase(MODIFY))) {
+      if (args[2].equalsIgnoreCase(RARITY)) {
+        return Arrays.stream(Rarity.values()).map(Enum::name).toList();
+      } else if (args[2].equalsIgnoreCase("type")) {
+        return Arrays.stream(ItemType.values()).map(Enum::name).toList();
+      } else if (args[2].equalsIgnoreCase(MATERIAL)) {
+        return Arrays.stream(Material.values()).map(Enum::name).toList();
+      } else if (args[2].equalsIgnoreCase(ENCHANTMENTS)) {
+        return List.of("add", REMOVE);
+      } else if (args[2].equalsIgnoreCase(ATTRIBUTES)) {
+        return List.of("add", REMOVE);
+      } else if (args[2].equalsIgnoreCase(ABILITIES)) {
+        return List.of("add", REMOVE);
+      } else if (args[2].equalsIgnoreCase(CUSTOMMODELDATA)) {
+          try {
+          Integer.parseInt(args[3]);
+          } catch (NumberFormatException e) {
+          return List.of("1");
+        }
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  private static List<String> argsLengthThree(@NotNull String @NotNull [] args) {
+    if (args.length == 3) {
+      if (args[0].equalsIgnoreCase(MODIFY)) {
+        return List.of(
+            "name",
+            MATERIAL,
+            ENCHANTMENTS,
+            ATTRIBUTES,
+            ABILITIES,
+            CUSTOMMODELDATA,
+            RARITY,
+            "type",
+            "description");
+      } else if (args[0].equalsIgnoreCase("give")) {
+        return Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
+      }
+    }
+    return null;
+  }
+
   /**
    * Executes the given command, returning its success. <br>
    * If false is returned, then the "usage" plugin.yml entry for this command (if defined) will be
@@ -54,279 +418,28 @@ public class ItemCommand implements TabExecutor {
     }
 
     if (args[0].equalsIgnoreCase("list")) {
-      ItemManager im = ItemManager.getInstance(ItemManager.class);
-      if (im.getItemIDs().isEmpty()) {
-        p.sendMessage(comp("<red>There are no items."));
-        return true;
-      }
-      p.sendMessage("Items:");
-      im.getItemIDs().forEach(p::sendMessage);
+      list(sender, p);
       return true;
     }
 
     if (args[0].equalsIgnoreCase("create")) {
-      if (args.length < 2) {
-        p.sendMessage("Usage: /item create <id>");
-        return true;
-      }
-      ItemManager im = ItemManager.getInstance(ItemManager.class);
-      if (im.getItemIDs().contains(args[1])) {
-        p.sendMessage(comp("<red>An item with that ID already exists."));
-        return true;
-      }
-      Item item = new Item();
-      item.setID(args[1]);
-      im.addItem(item);
-      p.sendMessage(
-          comp(
-              "<green>Item created. You can now modify it using "
-                  + "<click:suggest_command:/item "
-                  + "modify "
-                  + args[1]
-                  + "> /item modify "
-                  + args[1]
-                  + "</click>"));
+      create(sender, args);
       return true;
     }
 
-    if (args[0].equalsIgnoreCase("delete")) {
-      if (args.length < 2) {
-        p.sendMessage("Usage: /item delete <id>");
-        return true;
-      }
-      ItemManager im = ItemManager.getInstance(ItemManager.class);
-      if (!im.getItemIDs().contains(args[1])) {
-        p.sendMessage(comp("<red>An item with that ID does not exist."));
-        return true;
-      }
-      im.removeItem(args[1]);
-      p.sendMessage(comp("<green>Item deleted."));
+    if (args[0].equalsIgnoreCase(DELETE)) {
+      delete(sender, args, p);
       return true;
     }
 
     if (args[0].equalsIgnoreCase("give")) {
-      if (args.length < 2) {
-        p.sendMessage("Usage: /item give <id>");
-        return true;
-      }
-
-      ItemManager im = ItemManager.getInstance(ItemManager.class);
-      if (!im.getItemIDs().contains(args[1])) {
-        p.sendMessage(comp("<red>An item with that ID does not exist."));
-        return true;
-      }
-
-      Item item = im.getItem(args[1]);
-
-      if (args.length == 2) {
-        p.getInventory().addItem(item.toItemStack());
-        p.sendMessage(comp("<green>Item given."));
-        return true;
-      }
-
-      Player target = Bukkit.getPlayer(args[2]);
-      if (target == null) {
-        p.sendMessage(comp("<red>Player not found."));
-        return true;
-      }
-
-      target.getInventory().addItem(item.toItemStack());
-      p.sendMessage(comp("<green>Item given."));
-
+      give(sender, args, p);
       return true;
     }
 
-    if (args[0].equalsIgnoreCase("modify")) {
-      if (args.length < 2) {
-        p.sendMessage(
-            "Usage: /item modify <id> <name|material|enchantments|attributes|abilities|custommodeldata|rarity|type|description> [value]");
-        return true;
-      }
-
-      ItemManager im = ItemManager.getInstance(ItemManager.class);
-      if (!im.getItemIDs().contains(args[1])) {
-        p.sendMessage(comp("<red>An item with that ID does not exist."));
-        return true;
-      }
-
-      Item item = im.getItem(args[1]);
-
-      if (args.length == 2) {
-        p.sendMessage(
-            "Usage: /item modify <id> <name|material|enchantments|attributes|abilities|custommodeldata|rarity|type|description> [value]");
-        return true;
-      }
-
-      switch (args[2].toLowerCase()) {
-        case "name" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> name <value>");
-            return true;
-          }
-          String name = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
-          item.setName(name);
-          p.sendMessage(comp("<green>Item name set."));
-          // TODO: update item in player inventory
-          return true;
-        }
-        case "material" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> material <value>");
-            return true;
-          }
-          Material material = Material.matchMaterial(args[3]);
-          if (material == null) {
-            p.sendMessage(comp("<red>Material not found."));
-            return true;
-          }
-          item.setMaterial(material);
-          p.sendMessage(comp("<green>Item material set."));
-        }
-        case "enchantments" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> enchantments <add|remove> [enchantment]");
-            return true;
-          }
-          if (args[3].equalsIgnoreCase("add")) {
-            if (args.length < 5) {
-              p.sendMessage("Usage: /item modify <id> enchantments add <enchantment>");
-              return true;
-            }
-            // TODO: add enchantment
-            p.sendMessage("Enchantments not working for now.");
-            return true;
-          }
-          if (args[3].equalsIgnoreCase("remove")) {
-            if (args.length < 5) {
-              p.sendMessage("Usage: /item modify <id> enchantments remove <enchantment>");
-              return true;
-            }
-            // TODO: remove enchantment
-            p.sendMessage("Enchantments not working for now.");
-            return true;
-          }
-        }
-        case "attributes" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> attributes <add|remove> [attribute] [value]");
-            return true;
-          }
-          if (args[3].equalsIgnoreCase("add")) {
-            if (args.length < 6) {
-              p.sendMessage("Usage: /item modify <id> attributes add <attribute> <value>");
-              return true;
-            }
-            Attribute attribute = null;
-            try {
-              attribute = Attribute.valueOf(args[4]);
-            } catch (Exception e) {
-              p.sendMessage(comp("<red>Attribute not found."));
-              error("Error on attribute affectation on item: " + args[1] + "\n" + e);
-              return true;
-            }
-            double value;
-            try {
-              value = Double.parseDouble(args[5]);
-            } catch (NumberFormatException e) {
-              p.sendMessage(comp("<red>Invalid value."));
-              return true;
-            }
-            item.addAttribute(attribute, value);
-            p.sendMessage(comp("<green>Attribute added."));
-            return true;
-          }
-          if (args[3].equalsIgnoreCase("remove")) {
-            if (args.length < 5) {
-              p.sendMessage("Usage: /item modify <id> attributes remove <attribute>");
-              return true;
-            }
-            Attribute attribute = null;
-            try {
-              attribute = Attribute.valueOf(args[4]);
-            } catch (Exception e) {
-              p.sendMessage(comp("<red>Attribute not found."));
-              error("Error on attribute affectation on item: " + args[1] + "\n" + e);
-              return true;
-            }
-            item.removeAttribute(attribute);
-            p.sendMessage(comp("<green>Attribute removed."));
-            return true;
-          }
-          return true;
-        }
-        case "abilities" -> {
-          if (args.length < 5) {
-            p.sendMessage("Usage: /item modify <id> abilities add <ability>");
-            return true;
-          }
-          if (args[3].equalsIgnoreCase("add")) {
-            p.sendMessage("Abilities not working for now.");
-            // TODO: add ability
-          } else if (args[3].equalsIgnoreCase("remove")) {
-            p.sendMessage("Abilities not working for now.");
-            // TODO: remove ability
-          }
-          return true;
-        }
-        case "custommodeldata" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> custommodeldata <value>");
-            return true;
-          }
-          int customModelData;
-          try {
-            customModelData = Integer.parseInt(args[3]);
-          } catch (NumberFormatException e) {
-            p.sendMessage(comp("<red>Invalid value."));
-            return true;
-          }
-          item.setCustomModelData(customModelData);
-          p.sendMessage(comp("<green>Custom model data set."));
-          return true;
-        }
-        case "rarity" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> rarity <value>");
-            return true;
-          }
-          Rarity rarity;
-          try {
-            rarity = Rarity.valueOf(args[3]);
-          } catch (Exception e) {
-            p.sendMessage(comp("<red>Rarity not found."));
-            return true;
-          }
-          item.setRarity(rarity);
-          p.sendMessage(comp("<green>Rarity set."));
-          return true;
-        }
-        case "type" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> type <value>");
-            return true;
-          }
-          ItemType type;
-          try {
-            type = ItemType.valueOf(args[3]);
-          } catch (Exception e) {
-            p.sendMessage(comp("<red>Type not found."));
-            return true;
-          }
-          item.setType(type);
-          p.sendMessage(comp("<green>Type set."));
-          return true;
-        }
-        case "description" -> {
-          if (args.length < 4) {
-            p.sendMessage("Usage: /item modify <id> description <value>");
-            return true;
-          }
-          String description = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
-          item.setDescription(description);
-          p.sendMessage(comp("<green>Description set."));
-          return true;
-        }
-      }
+    if (args[0].equalsIgnoreCase(MODIFY)) {
+      modify(sender, args, p);
+      return true;
     }
 
     return true;
@@ -355,78 +468,33 @@ public class ItemCommand implements TabExecutor {
     }
 
     if (args.length == 1) {
-      return List.of("list", "create", "delete", "give", "modify");
+      return List.of("list", "create", DELETE, "give", MODIFY);
     }
 
-    if (args.length == 2) {
-      if (args[0].equalsIgnoreCase("delete")
-          || args[0].equalsIgnoreCase("give")
-          || args[0].equalsIgnoreCase("modify")) {
-        ItemManager im = ItemManager.getInstance(ItemManager.class);
+    if (args.length == 2
+        && (args[0].equalsIgnoreCase(DELETE)
+            || args[0].equalsIgnoreCase("give")
+            || args[0].equalsIgnoreCase(MODIFY))) {
+      ItemManager im = Manager.getInstance(ItemManager.class);
         return im.getItemIDs();
-      }
     }
 
-    if (args.length == 3) {
-      if (args[0].equalsIgnoreCase("modify")) {
-        return List.of(
-            "name",
-            "material",
-            "enchantments",
-            "attributes",
-            "abilities",
-            "custommodeldata",
-            "rarity",
-            "type",
-            "description");
-      } else if (args[0].equalsIgnoreCase("give")) {
-        return Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
-      }
-    }
+    List<String> completions = argsLengthThree(args);
+    if (completions != null) return completions;
 
-    if (args.length == 4) {
-      if (args[0].equalsIgnoreCase("modify")) {
-        if (args[2].equalsIgnoreCase("rarity")) {
-          return Arrays.stream(Rarity.values()).map(Enum::name).toList();
-        } else if (args[2].equalsIgnoreCase("type")) {
-          return Arrays.stream(ItemType.values()).map(Enum::name).toList();
-        } else if (args[2].equalsIgnoreCase("material")) {
-          return Arrays.stream(Material.values()).map(Enum::name).toList();
-        } else if (args[2].equalsIgnoreCase("enchantments")) {
-          return List.of("add", "remove");
-        } else if (args[2].equalsIgnoreCase("abilities")) {
-          return List.of("add", "remove");
-        } else if (args[2].equalsIgnoreCase("attributes")) {
-          return List.of("add", "remove");
-        } else if (args[2].equalsIgnoreCase("custommodeldata")) {
-          try {
-            Integer.parseInt(args[3]);
-          } catch (NumberFormatException e) {
-            return List.of("1");
-          }
-        }
-      }
-    }
+    completions = modifyCompletion(args);
+    if (completions != null) return completions;
 
-    if (args.length == 5) {
-      if (args[0].equalsIgnoreCase("modify")) {
-        /*if (args[2].equalsIgnoreCase("enchantments")) { // TODO: Enchantments in completion
-          return Arrays.stream(Enchantment.values()).map(Enum::name).toList();
-        } else*/ if (args[2].equalsIgnoreCase("attributes")) {
-          return Arrays.stream(Attribute.values()).map(Enum::name).toList();
-        }
-      }
-    }
+    completions = modify(args);
+    if (completions != null) return completions;
 
-    if (args.length == 6) {
-      if (args[0].equalsIgnoreCase("modify")) {
-        if (args[2].equalsIgnoreCase("attributes")) {
-          try {
-            Double.parseDouble(args[5]);
-          } catch (NumberFormatException e) {
-            return List.of("1.0");
-          }
-        }
+    if (args.length == 6
+        && (args[0].equalsIgnoreCase(MODIFY))
+        && (args[2].equalsIgnoreCase(ATTRIBUTES))) {
+      try {
+        Double.parseDouble(args[5]);
+      } catch (NumberFormatException e) {
+        return List.of("1.0");
       }
     }
 

src/main/java/me/unurled/sacredrealms/sr/commands/admin/LevelCommand.java

@@ -3,6 +3,7 @@ package me.unurled.sacredrealms.sr.commands.admin;
 import java.util.List;
 import me.unurled.sacredrealms.sr.components.player.PlayerManager;
 import me.unurled.sacredrealms.sr.components.player.SRPlayer;
+import me.unurled.sacredrealms.sr.managers.Manager;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -46,7 +47,7 @@ public class LevelCommand implements TabExecutor {
       return true;
     }
 
-    PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
+    PlayerManager pm = Manager.getInstance(PlayerManager.class);
     SRPlayer player = pm.getPlayer(target.getUniqueId());
 
     if (player != null) {

src/main/java/me/unurled/sacredrealms/sr/commands/player/ResetAdventureCommand.java

@@ -9,6 +9,7 @@ import java.util.Objects;
 import me.unurled.sacredrealms.sr.SR;
 import me.unurled.sacredrealms.sr.components.player.PlayerManager;
 import me.unurled.sacredrealms.sr.data.DataManager;
+import me.unurled.sacredrealms.sr.managers.Manager;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.command.Command;
@@ -42,29 +43,7 @@ public class ResetAdventureCommand implements TabExecutor {
       @NotNull String label,
       @NotNull String[] args) {
     if (sender.hasPermission("sr.resetadventure")) {
-      if (args.length > 2) {
-        sender.sendMessage(comp("<red>Usage: /resetadventure <player>"));
-        return true;
-      }
-      if (sender instanceof Player p) {
-        if (args.length == 0) {
-          boolean status = resetAdventure(p);
-          if (status) {
-            p.sendMessage(comp("<green>Your adventure has been reset."));
-          } else {
-            p.sendMessage(comp("<red>Failed to reset your adventure."));
-          }
-          return true;
-        }
-      }
-      OfflinePlayer player = SR.getInstance().getServer().getOfflinePlayer(args[0]);
-
-      boolean status = resetAdventure(player);
-      if (status) {
-        sender.sendMessage(comp("<green>Successfully reset " + player.getName() + "'s adventure."));
-      } else {
-        sender.sendMessage(comp("<red>Failed to reset " + player.getName() + "'s adventure."));
-      }
+      reset(sender, args);
       return true;
     }
     if (args.length > 0) {
@@ -76,7 +55,7 @@ public class ResetAdventureCommand implements TabExecutor {
         long lastUsed = cooldowns.get(player);
         long secondsLeft = ((lastUsed / 1000) + COOLDOWN) - (System.currentTimeMillis() / 1000);
         if (secondsLeft > 0) {
-          player.sendMessage(
+          sender.sendMessage(
               comp(
                   "<red>You must wait "
                       + secondsLeft
@@ -86,17 +65,41 @@ public class ResetAdventureCommand implements TabExecutor {
       }
       boolean status = resetAdventure(player);
       if (status) {
-        player.sendMessage(comp("<green>Your adventure has been reset."));
+        sender.sendMessage(comp("<green>Your adventure has been reset."));
       } else {
-        player.sendMessage(comp("<red>Failed to reset your adventure."));
+        sender.sendMessage(comp("<red>Failed to reset your adventure."));
       }
       cooldowns.put(player, System.currentTimeMillis());
     }
     return true;
   }
 
+  private void reset(@NotNull CommandSender sender, @NotNull String[] args) {
+    if (args.length > 2) {
+      sender.sendMessage(comp("<red>Usage: /resetadventure <player>"));
+      return;
+    }
+    if (sender instanceof Player p && (args.length == 0)) {
+      boolean status = resetAdventure(p);
+      if (status) {
+        sender.sendMessage(comp("<green>Your adventure has been reset."));
+      } else {
+        sender.sendMessage(comp("<red>Failed to reset your adventure."));
+      }
+      return;
+    }
+    OfflinePlayer player = SR.getInstance().getServer().getOfflinePlayer(args[0]);
+
+    boolean status = resetAdventure(player);
+    if (status) {
+      sender.sendMessage(comp("<green>Successfully reset " + player.getName() + "'s adventure."));
+    } else {
+      sender.sendMessage(comp("<red>Failed to reset " + player.getName() + "'s adventure."));
+    }
+  }
+
   private boolean resetAdventure(OfflinePlayer player) {
-    DataManager dataManager = DataManager.getInstance(DataManager.class);
+    DataManager dataManager = Manager.getInstance(DataManager.class);
     if (dataManager != null) {
       if (dataManager.getDataHandler().exists(PlayerManager.PLAYER_KEY + player.getUniqueId())) {
         dataManager.getDataHandler().remove(PlayerManager.PLAYER_KEY + player.getUniqueId());