Create Conflict config gui. (#4)

build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 group = "xyz.alexcrea"
-version = "1.3.2-A1"
+version = "1.3.2-A2"
 
 repositories {
     mavenCentral()

src/main/java/xyz/alexcrea/cuanvil/config/ConfigHolder.java

@@ -19,27 +19,27 @@ public abstract class ConfigHolder {
     public static ConflictConfigHolder CONFLICT_HOLDER;
     public static UnitRepairHolder UNIT_REPAIR_HOLDER;
 
-    public static boolean loadConfig(){
+    public static boolean loadConfig() {
         DEFAULT_CONFIG = new DefaultConfigHolder();
         ITEM_GROUP_HOLDER = new ItemGroupConfigHolder();
         CONFLICT_HOLDER = new ConflictConfigHolder();
         UNIT_REPAIR_HOLDER = new UnitRepairHolder();
 
         boolean result = reloadAllFromDisk(true);
-        if(result){
+        if (result) {
             MetricsUtil.INSTANCE.testIfConfigIsDefault();
         }
         return result;
     }
 
-    public static boolean reloadAllFromDisk(boolean hardfail){
+    public static boolean reloadAllFromDisk(boolean hardfail) {
 
         boolean sucess = DEFAULT_CONFIG.reloadFromDisk(hardfail);
-        if(!sucess) return false;
+        if (!sucess) return false;
         sucess = ITEM_GROUP_HOLDER.reloadFromDisk(hardfail);
-        if(!sucess) return false;
+        if (!sucess) return false;
         sucess = CONFLICT_HOLDER.reloadFromDisk(hardfail);
-        if(!sucess) return false;
+        if (!sucess) return false;
         sucess = UNIT_REPAIR_HOLDER.reloadFromDisk(hardfail);
         return sucess;
     }
@@ -49,43 +49,49 @@ public abstract class ConfigHolder {
     private static final File BACKUP_FOLDER = new File(CustomAnvil.instance.getDataFolder(), "backup");
 
     protected FileConfiguration configuration;
-    protected ConfigHolder(){
+
+    protected ConfigHolder() {
 
     }
 
     public abstract boolean reloadFromDisk(boolean hardFail);
+
     public abstract void reload();
-    public FileConfiguration getConfig(){
+
+    public FileConfiguration getConfig() {
         return configuration;
     }
 
     // Config name and files
     protected abstract String getConfigFileName();
 
-    protected String getConfigFileExtension(){
+    protected String getConfigFileExtension() {
         return ".yml";
     }
-    protected File getConfigFile(){
+
-        return new File(CustomAnvil.instance.getDataFolder(), getConfigFileName()+getConfigFileExtension());
+    protected File getConfigFile() {
+        return new File(CustomAnvil.instance.getDataFolder(), getConfigFileName() + getConfigFileExtension());
     }
-    protected File getFirstBackup(){
+
-        return new File(BACKUP_FOLDER, getConfigFileName()+"-first"+getConfigFileExtension());
+    protected File getFirstBackup() {
+        return new File(BACKUP_FOLDER, getConfigFileName() + "-first" + getConfigFileExtension());
     }
-    protected File getLastBackup(){
+
-        return new File(BACKUP_FOLDER, getConfigFileName()+"-latest"+getConfigFileExtension());
+    protected File getLastBackup() {
+        return new File(BACKUP_FOLDER, getConfigFileName() + "-latest" + getConfigFileExtension());
     }
 
     // Save logic
-    public boolean saveToDisk(boolean doBackup){
+    public boolean saveToDisk(boolean doBackup) {
-        if(doBackup){
+        if (doBackup) {
-            if(!saveBackup()){
+            if (!saveBackup()) {
                 CustomAnvil.instance.getLogger().severe("Could not save backup. see above.");
                 return false;
             }
         }
         File base = getConfigFile();
         // if file exist and can't be deleted the file, then we gave up.
-        if(base.exists() && !base.delete()) {
+        if (base.exists() && !base.delete()) {
             CustomAnvil.instance.getLogger().severe("Could not save config: can't delete existing file.");
             return false;
         }
@@ -101,15 +107,15 @@ public abstract class ConfigHolder {
         return true;
     }
 
-    protected boolean saveBackup(){
+    protected boolean saveBackup() {
         File base = getConfigFile();
-        if(!base.exists()) return true; // We did back up everything we had to (nothing in this case)
+        if (!base.exists()) return true; // We did back up everything we had to (nothing in this case)
         boolean sufficientSuccess = false;
 
         BACKUP_FOLDER.mkdirs();
         // save first backup if do not exist
         File firstBackup = getFirstBackup();
-        if(!firstBackup.exists()){
+        if (!firstBackup.exists()) {
             try {
                 Files.copy(base, firstBackup);
                 sufficientSuccess = true;
@@ -120,7 +126,7 @@ public abstract class ConfigHolder {
         // save last backup
         File lastBackup = getLastBackup();
         // if file exist and can't be deleted the file, then we gave up.
-        if(lastBackup.exists() && !lastBackup.delete()){
+        if (lastBackup.exists() && !lastBackup.delete()) {
             return sufficientSuccess;
         }
 
@@ -134,7 +140,7 @@ public abstract class ConfigHolder {
         return sufficientSuccess;
     }
 
-    public static class DefaultConfigHolder extends ConfigHolder{
+    public static class DefaultConfigHolder extends ConfigHolder {
 
         @Override
         protected String getConfigFileName() {
@@ -150,15 +156,17 @@ public abstract class ConfigHolder {
         }
 
         @Override
-        public void reload() {}// Nothing to do
+        public void reload() {
+        }// Nothing to do
 
     }
 
     // Abstract class for non default config
-    public abstract static class ResourceConfigHolder extends ConfigHolder{
+    public abstract static class ResourceConfigHolder extends ConfigHolder {
 
         String resourceName;
-        private ResourceConfigHolder(String resourceName){
+
+        private ResourceConfigHolder(String resourceName) {
             this.resourceName = resourceName;
         }
 
@@ -170,8 +178,8 @@ public abstract class ConfigHolder {
         @Override
         public boolean reloadFromDisk(boolean hardFail) {
             YamlConfiguration configuration = CustomAnvil.instance.reloadResource(
-                    getConfigFileName()+getConfigFileExtension(), hardFail);
+                    getConfigFileName() + getConfigFileExtension(), hardFail);
-            if(configuration == null) return false;
+            if (configuration == null) return false;
             this.configuration = configuration;
             reload();
             return true;
@@ -180,10 +188,11 @@ public abstract class ConfigHolder {
     }
 
     // Class for itemGroupsManager config
-    public static class ItemGroupConfigHolder extends ResourceConfigHolder{
+    public static class ItemGroupConfigHolder extends ResourceConfigHolder {
         private final static String FILE_NAME = "item_groups";
 
         ItemGroupManager itemGroupsManager;
+
         private ItemGroupConfigHolder() {
             super(FILE_NAME);
         }
@@ -198,7 +207,7 @@ public abstract class ConfigHolder {
             this.itemGroupsManager = new ItemGroupManager();
             this.itemGroupsManager.prepareGroups(this.configuration);
 
-            if(CONFLICT_HOLDER.getConfig() != null){
+            if (CONFLICT_HOLDER.getConfig() != null) {
                 CONFLICT_HOLDER.reload();
             }
         }
@@ -206,10 +215,11 @@ public abstract class ConfigHolder {
     }
 
     // Class for enchant conflict config
-    public static class ConflictConfigHolder extends ResourceConfigHolder{
+    public static class ConflictConfigHolder extends ResourceConfigHolder {
         private final static String FILE_NAME = "enchant_conflict";
 
         EnchantConflictManager conflictManager;
+
         private ConflictConfigHolder() {
             super(FILE_NAME);
         }
@@ -229,14 +239,16 @@ public abstract class ConfigHolder {
     }
 
     // Class for unit repair config
-    public static class UnitRepairHolder extends ResourceConfigHolder{
+    public static class UnitRepairHolder extends ResourceConfigHolder {
         private final static String ITEM_GROUP_FILE_NAME = "unit_repair_item";
 
         private UnitRepairHolder() {
             super(ITEM_GROUP_FILE_NAME);
         }
+
         @Override
-        public void reload() {} // Do nothing
+        public void reload() {
+        } // Do nothing
 
     }
 

src/main/java/xyz/alexcrea/cuanvil/enchant/EnchantmentProperties.java

@@ -41,12 +41,11 @@ public enum EnchantmentProperties {
     SWEEPING(EnchantmentRarity.RARE),
     THORNS(EnchantmentRarity.VERY_RARE),
     UNBREAKING(EnchantmentRarity.UNCOMMON),
-    VANISHING_CURSE(EnchantmentRarity.VERY_RARE)
+    VANISHING_CURSE(EnchantmentRarity.VERY_RARE);
-
-    ;
 
     private final EnchantmentRarity rarity;
-    EnchantmentProperties(EnchantmentRarity rarity){
+
+    EnchantmentProperties(EnchantmentRarity rarity) {
         this.rarity = rarity;
     }
 

src/main/java/xyz/alexcrea/cuanvil/enchant/EnchantmentRarity.java

@@ -7,19 +7,18 @@ public enum EnchantmentRarity {
     COMMON(1),
     UNCOMMON(2),
     RARE(4),
-    VERY_RARE(8)
+    VERY_RARE(8);
-
-    ;
 
     private final int itemValue;
     private final int bookValue;
 
-    EnchantmentRarity(int itemValue, int bookValue){
+    EnchantmentRarity(int itemValue, int bookValue) {
         this.itemValue = itemValue;
         this.bookValue = bookValue;
     }
-    EnchantmentRarity(int itemValue){
+
-        this(itemValue, Math.max(1,itemValue/2));
+    EnchantmentRarity(int itemValue) {
+        this(itemValue, Math.max(1, itemValue / 2));
     }
 
     public int getBookValue() {

src/main/java/xyz/alexcrea/cuanvil/gui/config/AbstractEnchantConfigGui.java

@@ -1,76 +1,41 @@
 package xyz.alexcrea.cuanvil.gui.config;
 
 import com.github.stefvanschie.inventoryframework.gui.GuiItem;
-import com.github.stefvanschie.inventoryframework.gui.type.util.Gui;
 import com.github.stefvanschie.inventoryframework.pane.Orientable;
 import com.github.stefvanschie.inventoryframework.pane.OutlinePane;
-import com.github.stefvanschie.inventoryframework.pane.Pane;
-import com.github.stefvanschie.inventoryframework.pane.PatternPane;
-import com.github.stefvanschie.inventoryframework.pane.util.Pattern;
 import io.delilaheve.CustomAnvil;
-import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
-import xyz.alexcrea.cuanvil.gui.MainConfigGui;
 import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
 import xyz.alexcrea.cuanvil.gui.config.settings.AbstractSettingGui;
-import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
 
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
 import java.util.List;
 
 /**
  * Abstract Global Config gui for enchantment setting configuration.
+ *
  * @param <T> Type of the factory of the type of setting the gui should edit.
  */
 public abstract class AbstractEnchantConfigGui<T extends AbstractSettingGui.SettingGuiFactory> extends ValueUpdatableGui {
 
-    private final static Material SECONDARY_BACKGROUND_MATERIAL = Material.BLACK_STAINED_GLASS_PANE;
-
-    private final Gui backGui;
-
     /**
      * Constructor for a gui displaying available enchantment to edit a enchantment setting.
+     *
      * @param title Title of the gui.
-     * @param backGui Gui to go back on click on the "back" button.
      */
-    protected AbstractEnchantConfigGui(String title, Gui backGui){
+    protected AbstractEnchantConfigGui(String title) {
         super(6, title, CustomAnvil.instance);
-        this.backGui = backGui;
-    }
-    /**
-     * Constructor for a gui displaying available enchantment to edit a enchantment setting.
-     * @param title Title of the gui.
-     */
-    protected AbstractEnchantConfigGui(String title){
-        this(title, MainConfigGui.INSTANCE);
     }
 
-    PatternPane backgroundItems;
+    private OutlinePane filledEnchant;
-    OutlinePane filledEnchant;
 
-    // Why is called like it is rn
     /**
      * Initialise value updatable gui pattern
-      */
+     */
-    protected void init(){
+    protected void init() {
         // Back item panel
-        Pattern pattern = new Pattern(
+        addPane(GuiSharedConstant.BACK_TO_MAIN_MENU_BIG_LIST_DISPLAY_BACKGROUND_PANE);
-                "000000000",
-                "000000000",
-                "000000000",
-                "000000000",
-                "000000000",
-                "B11111111"
-        );
-        this.backgroundItems = new PatternPane(0, 0, 9, 6, Pane.Priority.LOW, pattern);
-        addPane(this.backgroundItems);
-
-        GuiGlobalItems.addBackItem(this.backgroundItems, this.backGui);
-
-        GuiGlobalItems.addBackgroundItem(this.backgroundItems);
-        this.backgroundItems.bindItem('1', GuiGlobalItems.backgroundItem(SECONDARY_BACKGROUND_MATERIAL));
 
         // enchant item panel
         this.filledEnchant = new OutlinePane(0, 0, 9, 5);
@@ -87,13 +52,10 @@ public abstract class AbstractEnchantConfigGui<T extends AbstractSettingGui.Sett
     /**
      * Prepare enchantment config gui displayed items factory.
      */
-    protected void prepareValues(){
+    protected void prepareValues() {
         bookItemFactoryList = new ArrayList<>();
 
-        List<Enchantment> enchantments = Arrays.asList(Enchantment.values());
+        for (Enchantment enchant : GuiSharedConstant.SORTED_ENCHANTMENT_LIST) {
-        enchantments.sort(Comparator.comparing(ench -> ench.getKey().getKey()));
-
-        for (Enchantment enchant : enchantments) {
             T factory = getFactoryFromEnchant(enchant);
 
             bookItemFactoryList.add(factory);
@@ -102,6 +64,7 @@ public abstract class AbstractEnchantConfigGui<T extends AbstractSettingGui.Sett
 
     @Override
     public void updateGuiValues() {
+
         // probably not the most efficient but hey ! it do the work
         // TODO optimise one day.. maybe
 

src/main/java/xyz/alexcrea/cuanvil/gui/config/ConfirmActionGui.java

@@ -0,0 +1,94 @@
+package xyz.alexcrea.cuanvil.gui.config;
+
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
+import com.github.stefvanschie.inventoryframework.gui.type.ChestGui;
+import com.github.stefvanschie.inventoryframework.gui.type.util.Gui;
+import com.github.stefvanschie.inventoryframework.pane.PatternPane;
+import com.github.stefvanschie.inventoryframework.pane.util.Pattern;
+import io.delilaheve.CustomAnvil;
+import org.bukkit.Material;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions;
+import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+public class ConfirmActionGui extends ChestGui {
+
+    private static final ItemStack CANCEL_ITEM;
+    private static final ItemStack CONFIRM_ITEM;
+
+    static {
+        CANCEL_ITEM = new ItemStack(Material.RED_TERRACOTTA);
+        ItemMeta meta = CANCEL_ITEM.getItemMeta();
+        meta.setDisplayName("\u00A7cCancel");
+        meta.setLore(Collections.singletonList("\u00A77Cancel current action and return to previous menu."));
+        CANCEL_ITEM.setItemMeta(meta);
+
+        CONFIRM_ITEM = new ItemStack(Material.GREEN_TERRACOTTA);
+        meta = CONFIRM_ITEM.getItemMeta();
+        meta.setDisplayName("\u00A7aConfirm");
+        meta.setLore(Arrays.asList("\u00A77Confirm current action.",
+                "\u00A74Cation: This action can't be canceled."));
+        CONFIRM_ITEM.setItemMeta(meta);
+    }
+
+    public ConfirmActionGui(@NotNull String title, String actionDescription,
+                            Gui backOnCancel, Gui backOnConfirm, Supplier<Boolean> onConfirm) {
+        super(3, title, CustomAnvil.instance);
+
+        Pattern pattern = new Pattern(
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                "00B0I0S00",
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE
+        );
+        PatternPane pane = new PatternPane(0, 0, pattern.getLength(), pattern.getHeight(), pattern);
+        addPane(pane);
+
+        pane.bindItem('0', GuiGlobalItems.backgroundItem());
+
+        pane.bindItem('B', new GuiItem(CANCEL_ITEM, GuiGlobalActions.openGuiAction(backOnCancel), CustomAnvil.instance));
+        pane.bindItem('S', new GuiItem(CONFIRM_ITEM, event -> {
+            event.setCancelled(true);
+            HumanEntity player = event.getWhoClicked();
+
+            if (!player.hasPermission(CustomAnvil.editConfigPermission)) {
+                player.closeInventory();
+                player.sendMessage(GuiGlobalActions.NO_EDIT_PERM);
+                return;
+            }
+
+            boolean success;
+            try {
+                success = onConfirm.get();
+            } catch (Exception e) {
+                CustomAnvil.instance.getLogger().log(Level.WARNING, "Could not process confirmation supplier.", e);
+                success = false;
+            }
+
+            if (!success) {
+                event.getWhoClicked().sendMessage("\u00A7cAction could not be completed. ");
+            }
+            backOnConfirm.show(player);
+
+        }, CustomAnvil.instance));
+
+        ItemStack infoItem = new ItemStack(Material.PAPER);
+        ItemMeta infoMeta = infoItem.getItemMeta();
+
+        infoMeta.setDisplayName("\u00A7eAre you sure ?");
+        infoMeta.setLore(Arrays.asList(actionDescription.split("\n")));
+
+        infoItem.setItemMeta(infoMeta);
+
+        pane.bindItem('I', new GuiItem(infoItem, GuiGlobalActions.stayInPlace, CustomAnvil.instance));
+    }
+
+}

src/main/java/xyz/alexcrea/cuanvil/gui/config/SelectEnchantmentContainer.java

@@ -0,0 +1,15 @@
+package xyz.alexcrea.cuanvil.gui.config;
+
+import org.bukkit.enchantments.Enchantment;
+
+import java.util.Set;
+
+public interface SelectEnchantmentContainer {
+
+    Set<Enchantment> getSelectedEnchantments();
+
+    boolean setSelectedEnchantments(Set<Enchantment> enchantments);
+
+    Set<Enchantment> illegalEnchantments();
+
+}

src/main/java/xyz/alexcrea/cuanvil/gui/config/SelectGroupContainer.java

@@ -0,0 +1,15 @@
+package xyz.alexcrea.cuanvil.gui.config;
+
+import xyz.alexcrea.cuanvil.group.AbstractMaterialGroup;
+
+import java.util.Set;
+
+public interface SelectGroupContainer {
+
+    Set<AbstractMaterialGroup> getSelectedGroups();
+
+    boolean setSelectedGroups(Set<AbstractMaterialGroup> groups);
+
+    Set<AbstractMaterialGroup> illegalGroups();
+
+}

src/main/java/xyz/alexcrea/cuanvil/gui/config/SelectMaterialContainer.java

@@ -0,0 +1,15 @@
+package xyz.alexcrea.cuanvil.gui.config;
+
+import org.bukkit.Material;
+
+import java.util.EnumSet;
+
+public interface SelectMaterialContainer {
+
+    EnumSet<Material> getSelectedMaterials();
+
+    boolean setSelectedMaterials(EnumSet<Material> materials);
+
+    EnumSet<Material> illegalMaterials();
+
+}

src/main/java/xyz/alexcrea/cuanvil/gui/config/global/BasicConfigGui.java

@@ -1,4 +1,4 @@
-package xyz.alexcrea.cuanvil.gui.config;
+package xyz.alexcrea.cuanvil.gui.config.global;
 
 import com.github.stefvanschie.inventoryframework.gui.GuiItem;
 import com.github.stefvanschie.inventoryframework.pane.PatternPane;
@@ -10,12 +10,12 @@ import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 import xyz.alexcrea.cuanvil.config.ConfigHolder;
-import xyz.alexcrea.cuanvil.gui.MainConfigGui;
 import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
 import xyz.alexcrea.cuanvil.gui.config.settings.BoolSettingsGui;
 import xyz.alexcrea.cuanvil.gui.config.settings.IntSettingsGui;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
 
 import java.util.Collections;
 
@@ -33,7 +33,7 @@ public class BasicConfigGui extends ValueUpdatableGui {
     /**
      * Constructor of this Global gui for basic settings.
      */
-    private BasicConfigGui(){
+    private BasicConfigGui() {
         super(3, "\u00A78Basic Config", CustomAnvil.instance);
     }
 
@@ -42,9 +42,9 @@ public class BasicConfigGui extends ValueUpdatableGui {
     /**
      * Initialise Basic gui
      */
-    private void init(){
+    private void init() {
         Pattern pattern = new Pattern(
-                "000000000",
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
                 "012345670",
                 "B00000000"
         );
@@ -70,15 +70,15 @@ public class BasicConfigGui extends ValueUpdatableGui {
     /**
      * Prepare basic gui displayed items factory and static items..
      */
-    protected void prepareValues(){
+    protected void prepareValues() {
         // limit repair item
-        this.limitRepairFactory = BoolSettingsGui.boolFactory("\u00A78Limit Repair Cost ?",this,
+        this.limitRepairFactory = BoolSettingsGui.boolFactory("\u00A78Limit Repair Cost ?", this,
                 ConfigOptions.LIMIT_REPAIR_COST, ConfigHolder.DEFAULT_CONFIG, ConfigOptions.DEFAULT_LIMIT_REPAIR);
 
         // rename cost item
         IntRange range = ConfigOptions.REPAIR_LIMIT_RANGE;
         this.repairCostFactory = IntSettingsGui.intFactory("\u00A78Repair Cost Limit", this,
-                ConfigOptions.LIMIT_REPAIR_VALUE, ConfigHolder.DEFAULT_CONFIG, range.getFirst(),range.getLast(),
+                ConfigOptions.LIMIT_REPAIR_VALUE, ConfigHolder.DEFAULT_CONFIG, range.getFirst(), range.getLast(),
                 ConfigOptions.DEFAULT_LIMIT_REPAIR_VALUE,
                 1, 5, 10);
 
@@ -92,33 +92,33 @@ public class BasicConfigGui extends ValueUpdatableGui {
         this.notNeededLimitValueItem = new GuiItem(item, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
 
         // remove repair limit item
-        this.removeRepairLimit = BoolSettingsGui.boolFactory("\u00A78Remove Repair Limit ?",this,
+        this.removeRepairLimit = BoolSettingsGui.boolFactory("\u00A78Remove Repair Limit ?", this,
                 ConfigOptions.REMOVE_REPAIR_LIMIT, ConfigHolder.DEFAULT_CONFIG, ConfigOptions.DEFAULT_REMOVE_LIMIT);
 
         // item repair cost
         range = ConfigOptions.REPAIR_COST_RANGE;
         this.itemRepairCost = IntSettingsGui.intFactory("\u00A78Item Repair Cost", this,
-                ConfigOptions.ITEM_REPAIR_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(),range.getLast(),
+                ConfigOptions.ITEM_REPAIR_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(), range.getLast(),
                 ConfigOptions.DEFAULT_ITEM_REPAIR_COST,
                 1, 5, 10, 50, 100);
 
         // unit repair cost
         this.unitRepairCost = IntSettingsGui.intFactory("\u00A78Unit Repair Cost", this,
-                ConfigOptions.UNIT_REPAIR_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(),range.getLast(),
+                ConfigOptions.UNIT_REPAIR_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(), range.getLast(),
                 ConfigOptions.DEFAULT_UNIT_REPAIR_COST,
                 1, 5, 10, 50, 100);
 
         // item rename cost
         range = ConfigOptions.ITEM_RENAME_COST_RANGE;
         this.itemRenameCost = IntSettingsGui.intFactory("\u00A78Rename Cost", this,
-                ConfigOptions.ITEM_RENAME_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(),range.getLast(),
+                ConfigOptions.ITEM_RENAME_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(), range.getLast(),
                 ConfigOptions.DEFAULT_ITEM_RENAME_COST,
                 1, 5, 10, 50, 100);
 
         // sacrifice illegal enchant cost
         range = ConfigOptions.SACRIFICE_ILLEGAL_COST_RANGE;
         this.sacrificeIllegalEnchantCost = IntSettingsGui.intFactory("\u00A78Sacrifice Illegal Enchant Cost", this,
-                ConfigOptions.SACRIFICE_ILLEGAL_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(),range.getLast(),
+                ConfigOptions.SACRIFICE_ILLEGAL_COST, ConfigHolder.DEFAULT_CONFIG, range.getFirst(), range.getLast(),
                 ConfigOptions.DEFAULT_SACRIFICE_ILLEGAL_COST,
                 1, 5, 10, 50, 100);
 
@@ -132,9 +132,9 @@ public class BasicConfigGui extends ValueUpdatableGui {
 
         // rename cost item
         GuiItem limitRepairValueItem;
-        if(this.limitRepairFactory.getConfiguredValue()){
+        if (this.limitRepairFactory.getConfiguredValue()) {
             limitRepairValueItem = GuiGlobalItems.intSettingGuiItem(this.repairCostFactory, Material.EXPERIENCE_BOTTLE);
-        }else{
+        } else {
             limitRepairValueItem = this.notNeededLimitValueItem;
         }
         pane.bindItem('2', limitRepairValueItem);

src/main/java/xyz/alexcrea/cuanvil/gui/config/global/EnchantConflictGui.java

@@ -0,0 +1,407 @@
+package xyz.alexcrea.cuanvil.gui.config.global;
+
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
+import com.github.stefvanschie.inventoryframework.gui.type.ChestGui;
+import com.github.stefvanschie.inventoryframework.pane.Orientable;
+import com.github.stefvanschie.inventoryframework.pane.OutlinePane;
+import com.github.stefvanschie.inventoryframework.pane.Pane;
+import com.github.stefvanschie.inventoryframework.pane.PatternPane;
+import com.github.stefvanschie.inventoryframework.pane.util.Pattern;
+import io.delilaheve.CustomAnvil;
+import org.bukkit.Material;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import xyz.alexcrea.cuanvil.config.ConfigHolder;
+import xyz.alexcrea.cuanvil.group.EnchantConflictGroup;
+import xyz.alexcrea.cuanvil.group.IncludeGroup;
+import xyz.alexcrea.cuanvil.gui.config.settings.subsetting.EnchantConflictSubSettingGui;
+import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions;
+import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
+import xyz.alexcrea.cuanvil.util.CasedStringUtil;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+
+public class EnchantConflictGui extends ChestGui {
+
+    public final static EnchantConflictGui INSTANCE = new EnchantConflictGui();
+
+    static {
+        INSTANCE.init();
+    }
+
+    private final HashMap<EnchantConflictGroup, EnchantConflictSubSettingGui> conflictGuiMap;
+
+    private EnchantConflictGui() {
+        super(6, "Conflict Config", CustomAnvil.instance);
+        this.conflictGuiMap = new HashMap<>();
+    }
+
+    private OutlinePane firstPage;
+    private ArrayList<OutlinePane> pages;
+    private HashMap<UUID, Integer> pageMap;
+    private PatternPane backgroundPane;
+
+    private void init() {
+        // Back item panel
+        Pattern pattern = new Pattern(
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                "B11L1R11C"
+        );
+        this.backgroundPane = new PatternPane(0, 0, 9, 6, Pane.Priority.LOW, pattern);
+
+        GuiGlobalItems.addBackItem(this.backgroundPane, MainConfigGui.INSTANCE);
+
+        GuiGlobalItems.addBackgroundItem(this.backgroundPane);
+        this.backgroundPane.bindItem('1', GuiSharedConstant.SECONDARY_BACKGROUND_ITEM);
+        addPane(this.backgroundPane);
+
+        // Page init
+        this.pages = new ArrayList<>();
+        this.pageMap = new HashMap<>();
+
+        // enchant item panel
+        this.firstPage = createEmptyPage();
+        this.pages.add(this.firstPage);
+
+        prepareOtherValues();
+        reloadValues();
+    }
+
+
+    private GuiItem goLeftItem;
+    private GuiItem goRightItem;
+
+    private void prepareOtherValues() {
+        // Left item creation for consumer & bind
+        this.goLeftItem = new GuiItem(new ItemStack(Material.RED_TERRACOTTA), event -> {
+            HumanEntity viewer = event.getWhoClicked();
+            UUID playerUUID = viewer.getUniqueId();
+            int page = this.pageMap.getOrDefault(playerUUID, 0);
+            this.pageMap.put(playerUUID, page - 1);
+
+            ItemStack cursor = viewer.getItemOnCursor();
+            viewer.setItemOnCursor(new ItemStack(Material.AIR));
+
+            show(viewer);
+
+            viewer.setItemOnCursor(cursor);
+        }, CustomAnvil.instance);
+
+        // Right item creation for consumer & bind
+        this.goRightItem = new GuiItem(new ItemStack(Material.GREEN_TERRACOTTA), event -> {
+            HumanEntity viewer = event.getWhoClicked();
+            UUID playerUUID = viewer.getUniqueId();
+            int page = pageMap.getOrDefault(playerUUID, 0);
+            this.pageMap.put(playerUUID, page + 1);
+
+            ItemStack cursor = viewer.getItemOnCursor();
+            viewer.setItemOnCursor(new ItemStack(Material.AIR));
+
+            show(viewer);
+
+            viewer.setItemOnCursor(cursor);
+        }, CustomAnvil.instance);
+
+        // Create new conflict item
+        ItemStack createItem = new ItemStack(Material.PAPER);
+        ItemMeta createMeta = createItem.getItemMeta();
+
+        createMeta.setDisplayName("\u00A7aCreate new conflict");
+        createMeta.setLore(Arrays.asList(
+                "\u00A77Create a new anvil restriction.",
+                "\u00A77You will be asked to name the conflict in chat.",
+                "\u00A77Then, you should edit the conflict config as you need"
+        ));
+
+        createItem.setItemMeta(createMeta);
+
+        this.backgroundPane.bindItem('C', new GuiItem(createItem, (clickEvent) -> {
+            clickEvent.setCancelled(true);
+            HumanEntity player = clickEvent.getWhoClicked();
+
+            // check permission
+            if (!player.hasPermission(CustomAnvil.editConfigPermission)) {
+                player.closeInventory();
+                player.sendMessage(GuiGlobalActions.NO_EDIT_PERM);
+                return;
+            }
+            player.closeInventory();
+
+            player.sendMessage("\u00A7eWrite the conflict you want to create in the chat.\n" +
+                    "\u00A7eOr write \u00A7ccancel \u00A7eto go back to conflict config menu");
+
+            CustomAnvil.Companion.getChatListener().setListenedCallback(player, prepareCreateItemConsumer(player));
+
+        }, CustomAnvil.instance));
+    }
+
+    private Consumer<String> prepareCreateItemConsumer(HumanEntity player) {
+        AtomicReference<Consumer<String>> selfRef = new AtomicReference<>();
+        Consumer<String> selfCallback = (message) -> {
+            if (message == null) return;
+
+            message = message.toLowerCase(Locale.ROOT);
+            if ("cancel".equalsIgnoreCase(message)) {
+                player.sendMessage("conflict creation cancelled...");
+                show(player);
+                return;
+            }
+
+            message = message.replace(' ', '_');
+
+            // Try to find if it already exists in a for loop
+            // Not the most efficient on large number of conflict, but it should not run often.
+            for (EnchantConflictGroup conflict : ConfigHolder.CONFLICT_HOLDER.getConflictManager().getConflictList()) {
+                if (conflict.getName().equalsIgnoreCase(message)) {
+                    player.sendMessage("\u00A7cPlease enter a conflict name that do not already exist...");
+                    // wait next message.
+                    CustomAnvil.Companion.getChatListener().setListenedCallback(player, selfRef.get());
+                    return;
+                }
+            }
+
+            // Create new empty conflict and display it to the admin
+            EnchantConflictGroup conflict = new EnchantConflictGroup(
+                    message,
+                    new IncludeGroup("new_group"),
+                    0);
+
+            ConfigHolder.CONFLICT_HOLDER.getConflictManager().getConflictList().add(conflict);
+            updateValueForConflict(conflict, true);
+
+            // save empty conflict in config
+            String[] emptyStringArray = new String[0];
+
+            FileConfiguration config = ConfigHolder.CONFLICT_HOLDER.getConfig();
+            config.set(message + ".enchantments", emptyStringArray);
+            config.set(message + ".notAffectedGroups", emptyStringArray);
+            config.set(message + ".maxEnchantmentBeforeConflict", 0);
+
+            if (GuiSharedConstant.TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE) {
+                ConfigHolder.CONFLICT_HOLDER.saveToDisk(GuiSharedConstant.TEMPORARY_DO_BACKUP_EVERY_SAVE);
+            }
+
+            // show the new conflict config to the player
+            this.conflictGuiMap.get(conflict).show(player);
+
+        };
+
+        selfRef.set(selfCallback);
+        return selfCallback;
+    }
+
+    private OutlinePane createEmptyPage() {
+        OutlinePane page = new OutlinePane(0, 0, 9, 5);
+        page.align(OutlinePane.Alignment.BEGIN);
+        page.setOrientation(Orientable.Orientation.HORIZONTAL);
+
+        return page;
+    }
+
+    public void reloadValues() {
+        this.conflictGuiMap.forEach((conflict, gui) -> gui.cleanUnused());
+        this.conflictGuiMap.clear();
+        this.firstPage.clear();
+        this.pages.clear();
+        this.pages.add(this.firstPage);
+
+        for (EnchantConflictGroup conflict : ConfigHolder.CONFLICT_HOLDER.getConflictManager().getConflictList()) {
+            updateValueForConflict(conflict, false);
+        }
+
+        update();
+    }
+
+    public static ItemStack createItemForConflict(EnchantConflictGroup conflict) {
+        ItemStack item = new ItemStack(conflict.getRepresentativeMaterial());
+
+        ItemMeta meta = item.getItemMeta();
+
+        meta.setDisplayName("\u00A7e" + CasedStringUtil.snakeToUpperSpacedCase(conflict.getName()) + " \u00A7fConflict");
+        meta.setLore(Arrays.asList(
+                "\u00A77Enchantment count:      \u00A7e" + conflict.getEnchants().size(),
+                "\u00A77Group count:            \u00A7e" + conflict.getCantConflictGroup().getGroups().size(),
+                "\u00A77Min enchantments count: \u00A7e" + conflict.getMinBeforeBlock()
+        ));
+
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    public void updateValueForConflict(EnchantConflictGroup conflict, boolean shouldUpdate) {
+        EnchantConflictSubSettingGui gui = this.conflictGuiMap.get(conflict);
+        ItemStack item = createItemForConflict(conflict);
+
+        GuiItem guiItem;
+        if (gui == null) {
+            // Create new sub setting gui
+            guiItem = new GuiItem(item, CustomAnvil.instance);
+            gui = new EnchantConflictSubSettingGui(this, conflict, guiItem);
+
+            guiItem.setAction(GuiGlobalActions.openGuiAction(gui));
+
+            this.conflictGuiMap.put(conflict, gui);
+            addToPage(guiItem);
+        } else {
+            // Replace item with the updated one
+            guiItem = gui.getParentItemForThisGui();
+            guiItem.setItem(item);
+        }
+
+        gui.updateLocal();
+        if (shouldUpdate) {
+            update();
+        }
+
+    }
+
+    public void removeConflict(EnchantConflictGroup conflict) {
+        EnchantConflictSubSettingGui gui = this.conflictGuiMap.get(conflict);
+        if (gui == null) return;
+
+        this.conflictGuiMap.remove(conflict);
+        removeFromPage(gui.getParentItemForThisGui());
+
+        update();
+    }
+
+    private void addToPage(GuiItem guiItem) {
+        // Get first available page or create one
+        OutlinePane page = this.pages.get(this.pages.size() - 1);
+        if (page.getItems().size() >= 5 * 9) {
+            page = createEmptyPage();
+            this.pages.add(page);
+        }
+
+        page.addItem(guiItem);
+    }
+
+    private void removeFromPage(GuiItem guiItem) {
+        // get item page
+        OutlinePane page = null;
+        int pageID = 0;
+        while (pageID < this.pages.size()) {
+            OutlinePane tempPage = this.pages.get(pageID);
+            if (tempPage.getItems().contains(guiItem)) {
+                page = tempPage;
+                break;
+            }
+            pageID++;
+        }
+
+        if (page == null) {// Why...
+            return;
+        }
+        removeFromPage(page, pageID, guiItem);
+    }
+
+    private void removeFromPage(OutlinePane page, int pageID, GuiItem guiItem) {
+        page.removeItem(guiItem);
+
+        // There is now a slot available, let fill it if possible
+        if (pageID < (this.pages.size() - 1)) {
+            OutlinePane newPage = this.pages.get(pageID + 1);
+            GuiItem nextPageItem = newPage.getItems().get(0);
+
+            removeFromPage(newPage, pageID + 1, nextPageItem);
+
+            OutlinePane thisPage = this.pages.get(pageID);
+            thisPage.addItem(nextPageItem);
+        } else if (pageID > 0 && page.getItems().isEmpty()) {
+            this.pages.remove(pageID);
+        }
+    }
+
+
+    public int getPlayerPageID(UUID uuid) {
+        int pageId = this.pageMap.getOrDefault(uuid, 0);
+        if (pageId >= this.pages.size()) {
+            pageId = this.pages.size() - 1;
+        }
+        return pageId;
+    }
+
+    public void placeArrow(int page, boolean customise) {
+
+        // Place left arrow
+        addPane(this.backgroundPane);
+        if (page > 0) {
+            if (customise) {
+                ItemStack leftItem = this.goLeftItem.getItem();
+                ItemMeta leftMeta = leftItem.getItemMeta();
+
+                leftMeta.setDisplayName("\u00A7eReturn to page " + (page));
+
+                leftItem.setItemMeta(leftMeta);
+                this.goLeftItem.setItem(leftItem);
+            }
+
+            this.backgroundPane.bindItem('L', this.goLeftItem);
+        } else {
+            this.backgroundPane.bindItem('L', GuiSharedConstant.SECONDARY_BACKGROUND_ITEM);
+        }
+
+        // Place right arrow
+        if (page < pages.size() - 1) {
+            if (customise) {
+                ItemStack rightItem = this.goRightItem.getItem();
+                ItemMeta rightMeta = rightItem.getItemMeta();
+
+                rightMeta.setDisplayName("\u00A7eGo to page " + (page + 2));
+
+                rightItem.setItemMeta(rightMeta);
+                this.goRightItem.setItem(rightItem);
+            }
+
+            this.backgroundPane.bindItem('R', this.goRightItem);
+        } else {
+            this.backgroundPane.bindItem('R', GuiSharedConstant.SECONDARY_BACKGROUND_ITEM);
+        }
+    }
+
+    @Override // assume will not be called in multiple thread
+    public void show(@NotNull HumanEntity humanEntity) {
+        int pageID = getPlayerPageID(humanEntity.getUniqueId());
+        OutlinePane page = this.pages.get(pageID);
+
+        getPanes().clear();
+
+        // display the page arrow pane
+        placeArrow(pageID, true);
+        // and add actual page
+        addPane(page);
+
+        // set title
+        setTitle("Conflict Config (" + (pageID + 1) + "/" + (pages.size()) + ")");
+
+        super.show(humanEntity);
+
+    }
+
+    @Override // assume will not be called in multiple thread
+    public void click(@NotNull InventoryClickEvent event) {
+        int pageID = getPlayerPageID(event.getWhoClicked().getUniqueId());
+        OutlinePane page = this.pages.get(pageID);
+
+        getPanes().clear();
+
+        // set the page arrow pane
+        placeArrow(pageID, false);
+        // and add actual page
+        addPane(page);
+
+        super.click(event);
+    }
+
+}

src/main/java/xyz/alexcrea/cuanvil/gui/config/global/EnchantCostConfigGui.java

@@ -1,4 +1,4 @@
-package xyz.alexcrea.cuanvil.gui.config;
+package xyz.alexcrea.cuanvil.gui.config.global;
 
 import com.github.stefvanschie.inventoryframework.gui.GuiItem;
 import org.bukkit.Material;
@@ -8,6 +8,7 @@ import org.bukkit.inventory.meta.ItemMeta;
 import xyz.alexcrea.cuanvil.config.ConfigHolder;
 import xyz.alexcrea.cuanvil.enchant.EnchantmentProperties;
 import xyz.alexcrea.cuanvil.enchant.EnchantmentRarity;
+import xyz.alexcrea.cuanvil.gui.config.AbstractEnchantConfigGui;
 import xyz.alexcrea.cuanvil.gui.config.settings.EnchantCostSettingsGui;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
 import xyz.alexcrea.cuanvil.util.CasedStringUtil;
@@ -45,10 +46,11 @@ public class EnchantCostConfigGui extends AbstractEnchantConfigGui<EnchantCostSe
         EnchantmentRarity rarity = EnchantmentRarity.NO_RARITY;
         try {
             rarity = EnchantmentProperties.valueOf(key.toUpperCase(Locale.ENGLISH)).getRarity();
-        }catch (IllegalArgumentException ignored){}
+        } catch (IllegalArgumentException ignored) {
+        }
 
-        return EnchantCostSettingsGui.enchantCostFactory(prettyKey+" Level Cost", this,
+        return EnchantCostSettingsGui.enchantCostFactory(prettyKey + " Level Cost", this,
-                SECTION_NAME+'.'+key, ConfigHolder.DEFAULT_CONFIG, 0, 255,
+                SECTION_NAME + '.' + key, ConfigHolder.DEFAULT_CONFIG, 0, 255,
                 rarity.getItemValue(), rarity.getBookValue(),
                 1, 10, 50);
     }
@@ -58,13 +60,13 @@ public class EnchantCostConfigGui extends AbstractEnchantConfigGui<EnchantCostSe
         // Get item properties
         int itemCost = factory.getConfiguredValue();
         int bookCost = factory.getConfiguredBookValue();
-        StringBuilder itemName = new StringBuilder("\u00A7a").append(factory.getTitle());
+        String itemName = "\u00A7a" + factory.getTitle();
         // Create item
         ItemStack item = new ItemStack(Material.ENCHANTED_BOOK);
         ItemMeta itemMeta = item.getItemMeta();
 
         // Edit name and lore
-        itemMeta.setDisplayName(itemName.toString());
+        itemMeta.setDisplayName(itemName);
         itemMeta.setLore(Arrays.asList(
                 "\u00A77Item  Cost: " + itemCost,
                 "\u00A77Book Cost: " + bookCost));

src/main/java/xyz/alexcrea/cuanvil/gui/config/global/EnchantLimitConfigGui.java

@@ -1,9 +1,10 @@
-package xyz.alexcrea.cuanvil.gui.config;
+package xyz.alexcrea.cuanvil.gui.config.global;
 
 import com.github.stefvanschie.inventoryframework.gui.GuiItem;
 import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
 import xyz.alexcrea.cuanvil.config.ConfigHolder;
+import xyz.alexcrea.cuanvil.gui.config.AbstractEnchantConfigGui;
 import xyz.alexcrea.cuanvil.gui.config.settings.IntSettingsGui;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
 import xyz.alexcrea.cuanvil.util.CasedStringUtil;
@@ -36,8 +37,8 @@ public class EnchantLimitConfigGui extends AbstractEnchantConfigGui<IntSettingsG
         String key = enchant.getKey().getKey().toLowerCase(Locale.ROOT);
         String prettyKey = CasedStringUtil.snakeToUpperSpacedCase(key);
 
-        return IntSettingsGui.intFactory(prettyKey+" Level Limit", this,
+        return IntSettingsGui.intFactory(prettyKey + " Level Limit", this,
-                SECTION_NAME+'.'+key, ConfigHolder.DEFAULT_CONFIG, 0, 255,
+                SECTION_NAME + '.' + key, ConfigHolder.DEFAULT_CONFIG, 0, 255,
                 enchant.getMaxLevel(),
                 1, 5, 10, 50, 100);
     }

src/main/java/xyz/alexcrea/cuanvil/gui/config/global/MainConfigGui.java

@@ -1,4 +1,4 @@
-package xyz.alexcrea.cuanvil.gui;
+package xyz.alexcrea.cuanvil.gui.config.global;
 
 import com.github.stefvanschie.inventoryframework.gui.GuiItem;
 import com.github.stefvanschie.inventoryframework.gui.type.ChestGui;
@@ -8,9 +8,6 @@ import io.delilaheve.CustomAnvil;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
-import xyz.alexcrea.cuanvil.gui.config.BasicConfigGui;
-import xyz.alexcrea.cuanvil.gui.config.EnchantCostConfigGui;
-import xyz.alexcrea.cuanvil.gui.config.EnchantLimitConfigGui;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
 
@@ -23,12 +20,13 @@ public class MainConfigGui extends ChestGui {
     static {
         INSTANCE.init();
     }
+
     private MainConfigGui() {
         super(3, "\u00A78Anvil Config", CustomAnvil.instance);
 
     }
 
-    private void init(){
+    private void init() {
         Pattern pattern = new Pattern(
                 "I00000000",
                 "012304560",
@@ -72,17 +70,26 @@ public class MainConfigGui extends ChestGui {
         GuiItem enchantCostItem = GuiGlobalItems.goToGuiItem(enchantCostItemstack, EnchantCostConfigGui.INSTANCE);
         pane.bindItem('3', enchantCostItem);
 
+        // Enchantment Conflicts
+        ItemStack EnchantConflictItemstack = new ItemStack(Material.OAK_FENCE);
+        ItemMeta enchantConflictMeta = EnchantConflictItemstack.getItemMeta();
+
+        enchantConflictMeta.setDisplayName("\u00A7aEnchantment Conflict");
+        enchantConflictMeta.setLore(Collections.singletonList("\u00A77Click here to open enchantment conflict menu"));
+        EnchantConflictItemstack.setItemMeta(enchantConflictMeta);
+
+        GuiItem enchantConflictItem = GuiGlobalItems.goToGuiItem(EnchantConflictItemstack, EnchantConflictGui.INSTANCE);
+        pane.bindItem('4', enchantConflictItem);
+
         // WIP configuration items
         ItemStack wipItemstack = new ItemStack(Material.BARRIER);
         ItemMeta wipMeta = wipItemstack.getItemMeta();
         wipMeta.setDisplayName("\u00A7cWIP");
         wipItemstack.setItemMeta(wipMeta);
 
-        GuiItem wip4 = new GuiItem(wipItemstack, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
         GuiItem wip5 = new GuiItem(wipItemstack, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
         GuiItem wip6 = new GuiItem(wipItemstack, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
 
-        pane.bindItem('4', wip4);
         pane.bindItem('5', wip5);
         pane.bindItem('6', wip6);
 
@@ -95,7 +102,7 @@ public class MainConfigGui extends ChestGui {
         GuiItem quitItem = new GuiItem(quitItemstack, event -> {
             event.setCancelled(true);
             event.getWhoClicked().closeInventory();
-        },CustomAnvil.instance);
+        }, CustomAnvil.instance);
         pane.bindItem('Q', quitItem);
 
         // create & bind "info" item

src/main/java/xyz/alexcrea/cuanvil/gui/config/settings/AbstractSettingGui.java

@@ -20,18 +20,15 @@ import java.util.List;
  */
 public abstract class AbstractSettingGui extends ChestGui {
 
-    // Temporary values, until I get something better.
-    public static final boolean TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE = true;
-    public static final boolean TEMPORARY_DO_BACKUP_EVERY_SAVE = true;
-
     protected final static List<String> CLICK_LORE = Collections.singletonList("\u00A77Click Here to change the value");
 
     private PatternPane pane;
 
     /**
      * Prepare necessary object for a setting gui.
-     * @param rows Number of row for this gui.
+     *
-     * @param title Title of this gui.
+     * @param rows   Number of row for this gui.
+     * @param title  Title of this gui.
      * @param parent Parent gui to go back when completed.
      */
     public AbstractSettingGui(int rows, @NotNull TextHolder title, ValueUpdatableGui parent) {
@@ -41,8 +38,9 @@ public abstract class AbstractSettingGui extends ChestGui {
 
     /**
      * Prepare necessary object for a setting gui.
-     * @param rows Number of row for this gui.
+     *
-     * @param title Title of this gui.
+     * @param rows   Number of row for this gui.
+     * @param title  Title of this gui.
      * @param parent Parent gui to go back when completed.
      */
     public AbstractSettingGui(int rows, @NotNull String title, ValueUpdatableGui parent) {
@@ -54,9 +52,10 @@ public abstract class AbstractSettingGui extends ChestGui {
 
     /**
      * Initialise and prepare value for this gui.
+     *
      * @param parent Parent gui to go back when completed.
      */
-    private void initBase(ValueUpdatableGui parent){
+    private void initBase(ValueUpdatableGui parent) {
         Pattern pattern = getGuiPattern();
         pane = new PatternPane(0, 0, pattern.getLength(), pattern.getHeight(), pattern);
         addPane(pane);
@@ -79,6 +78,7 @@ public abstract class AbstractSettingGui extends ChestGui {
 
     /**
      * Get main pane for this setting gui.
+     *
      * @return Main pattern pain of this gui.
      */
     protected PatternPane getPane() {
@@ -93,12 +93,14 @@ public abstract class AbstractSettingGui extends ChestGui {
      * <li><b>B</b>: "back to previous gui" button.</li>
      * <li><b>0</b>: default background item.</li>
      * </ul>
+     *
      * @return The gui's pattern.
      */
     protected abstract Pattern getGuiPattern();
 
     /**
      * Called when the associated setting need to be saved.
+     *
      * @return true if the save was successful. false otherwise
      */
     public abstract boolean onSave();
@@ -106,6 +108,7 @@ public abstract class AbstractSettingGui extends ChestGui {
     /**
      * If this function return true
      * the gui assume the associated setting can be saved.
+     *
      * @return true if there is a change to the setting. false otherwise
      */
     public abstract boolean hadChange();
@@ -115,16 +118,17 @@ public abstract class AbstractSettingGui extends ChestGui {
      * <p>
      * It is better to keep a factory that hold setting data than find what parameters to use every time.
      */
-    public abstract static class SettingGuiFactory{
+    public abstract static class SettingGuiFactory {
         protected String configPath;
         protected ConfigHolder config;
 
         /**
          * Constructor for settings gui factory
+         *
          * @param configPath Configuration path of this setting.
-         * @param config Configuration holder of this setting.
+         * @param config     Configuration holder of this setting.
          */
-        protected SettingGuiFactory(String configPath, ConfigHolder config){
+        protected SettingGuiFactory(String configPath, ConfigHolder config) {
             this.configPath = configPath;
             this.config = config;
         }
@@ -145,6 +149,7 @@ public abstract class AbstractSettingGui extends ChestGui {
 
         /**
          * Create a gui using setting parameters and current setting value.
+         *
          * @return A new instance of the implemented setting gui.
          */
         public abstract AbstractSettingGui create();

src/main/java/xyz/alexcrea/cuanvil/gui/config/settings/BoolSettingsGui.java

@@ -12,6 +12,7 @@ import org.jetbrains.annotations.NotNull;
 import xyz.alexcrea.cuanvil.config.ConfigHolder;
 import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
 import xyz.alexcrea.cuanvil.util.MetricsUtil;
 
 import java.util.Collections;
@@ -20,7 +21,7 @@ import java.util.function.Consumer;
 /**
  * An instance of a gui used to edit a boolean setting.
  */
-public class BoolSettingsGui extends AbstractSettingGui{
+public class BoolSettingsGui extends AbstractSettingGui {
 
     private final BoolSettingFactory holder;
     private final boolean before;
@@ -28,8 +29,9 @@ public class BoolSettingsGui extends AbstractSettingGui{
 
     /**
      * Create a boolean setting config gui.
+     *
      * @param holder Configuration factory of this setting.
-     * @param now The defined value of this setting.
+     * @param now    The defined value of this setting.
      */
     protected BoolSettingsGui(BoolSettingFactory holder, boolean now) {
         super(3, holder.getTitle(), holder.parent);
@@ -45,7 +47,7 @@ public class BoolSettingsGui extends AbstractSettingGui{
     @Override
     public Pattern getGuiPattern() {
         return new Pattern(
-                "000000000",
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
                 "D0-0v0+00",
                 "B0000000S"
         );
@@ -56,12 +58,12 @@ public class BoolSettingsGui extends AbstractSettingGui{
     /**
      * Prepare "return to default value" gui item.
      */
-    protected void prepareReturnToDefault(){
+    protected void prepareReturnToDefault() {
         ItemStack item = new ItemStack(Material.COMMAND_BLOCK);
         ItemMeta meta = item.getItemMeta();
 
         meta.setDisplayName("\u00A7eReset to default value");
-        meta.setLore(Collections.singletonList("\u00A77Default value is: "+holder.defaultVal));
+        meta.setLore(Collections.singletonList("\u00A77Default value is: " + holder.defaultVal));
         item.setItemMeta(meta);
         returnToDefault = new GuiItem(item, event -> {
             event.setCancelled(true);
@@ -74,16 +76,16 @@ public class BoolSettingsGui extends AbstractSettingGui{
     /**
      * Update item using the setting value to match the new value
      */
-    protected void updateValueDisplay(){
+    protected void updateValueDisplay() {
         PatternPane pane = getPane();
 
         // Get displayed value for this config.
         String displayedName;
         Material displayedMat;
-        if(now){
+        if (now) {
             displayedName = "\u00A7aTrue";
             displayedMat = Material.GREEN_TERRACOTTA;
-        }else{
+        } else {
             displayedName = "\u00A7cFalse";
             displayedMat = Material.RED_TERRACOTTA;
         }
@@ -99,9 +101,9 @@ public class BoolSettingsGui extends AbstractSettingGui{
 
         // reset to default
         GuiItem returnToDefault;
-        if(now != holder.defaultVal){
+        if (now != holder.defaultVal) {
             returnToDefault = this.returnToDefault;
-        }else{
+        } else {
             returnToDefault = GuiGlobalItems.backgroundItem();
         }
         pane.bindItem('D', returnToDefault);
@@ -111,8 +113,8 @@ public class BoolSettingsGui extends AbstractSettingGui{
     /**
      * @return A consumer to update the current setting's value.
      */
-    protected Consumer<InventoryClickEvent> inverseNowConsumer(){
+    protected Consumer<InventoryClickEvent> inverseNowConsumer() {
-        return event->{
+        return event -> {
             event.setCancelled(true);
             now = !now;
             updateValueDisplay();
@@ -125,8 +127,8 @@ public class BoolSettingsGui extends AbstractSettingGui{
         holder.config.getConfig().set(holder.configPath, now);
 
         MetricsUtil.INSTANCE.notifyChange(this.holder.config, this.holder.configPath);
-        if(TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE){
+        if (GuiSharedConstant.TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE) {
-            return holder.config.saveToDisk(TEMPORARY_DO_BACKUP_EVERY_SAVE);
+            return holder.config.saveToDisk(GuiSharedConstant.TEMPORARY_DO_BACKUP_EVERY_SAVE);
         }
         return true;
     }
@@ -138,18 +140,19 @@ public class BoolSettingsGui extends AbstractSettingGui{
 
     /**
      * Create a bool setting factory from setting's parameters.
-     * @param title The title of the gui.
+     *
-     * @param parent Parent gui to go back when completed.
+     * @param title      The title of the gui.
+     * @param parent     Parent gui to go back when completed.
      * @param configPath Configuration path of this setting.
-     * @param config Configuration holder of this setting.
+     * @param config     Configuration holder of this setting.
      * @param defaultVal Default value if not found on the config.
      * @return A factory for a boolean setting gui.
      */
     public static BoolSettingFactory boolFactory(@NotNull String title, ValueUpdatableGui parent,
                                                  String configPath, ConfigHolder config,
-                                                 boolean defaultVal){
+                                                 boolean defaultVal) {
         return new BoolSettingFactory(
-                title,parent,
+                title, parent,
                 configPath, config,
                 defaultVal);
     }
@@ -157,22 +160,25 @@ public class BoolSettingsGui extends AbstractSettingGui{
     /**
      * A factory for a boolean setting gui that hold setting's information.
      */
-    public static class BoolSettingFactory extends SettingGuiFactory{
+    public static class BoolSettingFactory extends SettingGuiFactory {
-        @NotNull String title; ValueUpdatableGui parent;
+        @NotNull
+        String title;
+        ValueUpdatableGui parent;
         boolean defaultVal;
 
         /**
          * Constructor for a boolean setting gui factory.
-         * @param title The title of the gui.
+         *
-         * @param parent Parent gui to go back when completed.
+         * @param title      The title of the gui.
+         * @param parent     Parent gui to go back when completed.
          * @param configPath Configuration path of this setting.
-         * @param config Configuration holder of this setting.
+         * @param config     Configuration holder of this setting.
          * @param defaultVal Default value if not found on the config.
          */
         protected BoolSettingFactory(
                 @NotNull String title, ValueUpdatableGui parent,
                 String configPath, ConfigHolder config,
-                boolean defaultVal){
+                boolean defaultVal) {
             super(configPath, config);
             this.title = title;
             this.parent = parent;
@@ -191,7 +197,7 @@ public class BoolSettingsGui extends AbstractSettingGui{
         /**
          * @return The configured value for the associated setting.
          */
-        public boolean getConfiguredValue(){
+        public boolean getConfiguredValue() {
             return this.config.getConfig().getBoolean(this.configPath, this.defaultVal);
         }
 

src/main/java/xyz/alexcrea/cuanvil/gui/config/settings/EnchantCostSettingsGui.java

@@ -14,6 +14,7 @@ import xyz.alexcrea.cuanvil.config.ConfigHolder;
 import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
 import xyz.alexcrea.cuanvil.util.MetricsUtil;
 
 import java.util.Arrays;
@@ -33,7 +34,8 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
 
     /**
      * Create an enchantment cost setting config gui.
-     * @param holder Configuration factory of this setting.
+     *
+     * @param holder  Configuration factory of this setting.
      * @param nowItem The defined value of this setting item's value.
      */
     protected EnchantCostSettingsGui(EnchantCostSettingFactory holder, int nowItem) {
@@ -53,7 +55,7 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
     protected void initStepsValue() {
         super.initStepsValue();
 
-        int nowBook = ((EnchantCostSettingFactory)this.holder).getConfiguredBookValue();
+        int nowBook = ((EnchantCostSettingFactory) this.holder).getConfiguredBookValue();
         this.beforeBook = nowBook;
         this.nowBook = nowBook;
     }
@@ -80,7 +82,8 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
         bookMeta.setDisplayName("\u00A7aCost of an Enchantment by Book");
         bookMeta.setLore(Arrays.asList(
                 "\u00A77Cost per result item level of an sacrifice enchantment",
-                "\u00A77Only apply if sacrificed item \u00A7cis \u00A77a book"));bookItemstack.setItemMeta(bookMeta);
+                "\u00A77Only apply if sacrificed item \u00A7cis \u00A77a book"));
+        bookItemstack.setItemMeta(bookMeta);
 
         // sword display
         ItemStack swordItemstack = new ItemStack(Material.WOODEN_SWORD);
@@ -94,12 +97,12 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
         swordItemstack.setItemMeta(swordMeta);
 
         pane.bindItem('1', GuiGlobalItems.backgroundItem(Material.BLACK_STAINED_GLASS_PANE));
-        pane.bindItem('2', new GuiItem(bookItemstack,  GuiGlobalActions.stayInPlace, CustomAnvil.instance));
+        pane.bindItem('2', new GuiItem(bookItemstack, GuiGlobalActions.stayInPlace, CustomAnvil.instance));
         pane.bindItem('3', new GuiItem(swordItemstack, GuiGlobalActions.stayInPlace, CustomAnvil.instance));
     }
 
     @Override
-    protected void prepareReturnToDefault(){
+    protected void prepareReturnToDefault() {
         ItemStack item = new ItemStack(Material.COMMAND_BLOCK);
         ItemMeta meta = item.getItemMeta();
 
@@ -117,11 +120,11 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
             now = holder.defaultVal;
             updateValueDisplay();
             update();
-            }, CustomAnvil.instance);
+        }, CustomAnvil.instance);
     }
 
     @Override
-    protected void updateValueDisplay(){
+    protected void updateValueDisplay() {
         super.updateValueDisplay();
         PatternPane pane = getPane();
 
@@ -132,32 +135,32 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
 
         // minus item
         GuiItem minusItem;
-        if(nowBook > holder.min){
+        if (nowBook > holder.min) {
             int planned = Math.max(holder.min, nowBook - step);
             ItemStack item = new ItemStack(Material.RED_TERRACOTTA);
             ItemMeta meta = item.getItemMeta();
-            meta.setDisplayName("\u00A7e"+nowBook+" -> "+planned + " \u00A7r(\u00A7c-"+(nowBook-planned)+"\u00A7r)");
+            meta.setDisplayName("\u00A7e" + nowBook + " -> " + planned + " \u00A7r(\u00A7c-" + (nowBook - planned) + "\u00A7r)");
             meta.setLore(AbstractSettingGui.CLICK_LORE);
             item.setItemMeta(meta);
 
             minusItem = new GuiItem(item, updateNowBookConsumer(planned), CustomAnvil.instance);
-        }else{
+        } else {
             minusItem = GuiGlobalItems.backgroundItem(Material.BARRIER);
         }
         pane.bindItem('M', minusItem);
 
         //plus item
         GuiItem plusItem;
-        if(nowBook < holder.max){
+        if (nowBook < holder.max) {
             int planned = Math.min(holder.max, nowBook + step);
             ItemStack item = new ItemStack(Material.GREEN_TERRACOTTA);
             ItemMeta meta = item.getItemMeta();
-            meta.setDisplayName("\u00A7e"+nowBook+" -> "+planned + " \u00A7r(\u00A7a+"+(planned-nowBook)+"\u00A7r)");
+            meta.setDisplayName("\u00A7e" + nowBook + " -> " + planned + " \u00A7r(\u00A7a+" + (planned - nowBook) + "\u00A7r)");
             meta.setLore(AbstractSettingGui.CLICK_LORE);
             item.setItemMeta(meta);
 
             plusItem = new GuiItem(item, updateNowBookConsumer(planned), CustomAnvil.instance);
-        }else{
+        } else {
             plusItem = GuiGlobalItems.backgroundItem(Material.BARRIER);
         }
         pane.bindItem('P', plusItem);
@@ -165,7 +168,7 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
         // "result" display
         ItemStack resultPaper = new ItemStack(Material.PAPER);
         ItemMeta resultMeta = resultPaper.getItemMeta();
-        resultMeta.setDisplayName("\u00A7eValue: "+nowBook);
+        resultMeta.setDisplayName("\u00A7eValue: " + nowBook);
         resultPaper.setItemMeta(resultMeta);
         GuiItem resultItem = new GuiItem(resultPaper, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
 
@@ -173,9 +176,9 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
 
         // reset to default
         GuiItem returnToDefault;
-        if(now != holder.defaultVal || nowBook != holder.defaultBookVal){
+        if (now != holder.defaultVal || nowBook != holder.defaultBookVal) {
             returnToDefault = this.returnToDefault;
-        }else{
+        } else {
             returnToDefault = GuiGlobalItems.backgroundItem();
         }
         pane.bindItem('D', returnToDefault);
@@ -187,8 +190,8 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
      * @param planned Value to change current book cost setting to.
      * @return A consumer to update the current book cost setting's value.
      */
-    protected Consumer<InventoryClickEvent> updateNowBookConsumer(int planned){
+    protected Consumer<InventoryClickEvent> updateNowBookConsumer(int planned) {
-        return event->{
+        return event -> {
             event.setCancelled(true);
             nowBook = planned;
             updateValueDisplay();
@@ -203,12 +206,12 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
 
     @Override
     public boolean onSave() {
-        holder.config.getConfig().set(holder.configPath+ITEM_PATH, now);
+        holder.config.getConfig().set(holder.configPath + ITEM_PATH, now);
-        holder.config.getConfig().set(holder.configPath+BOOK_PATH, nowBook);
+        holder.config.getConfig().set(holder.configPath + BOOK_PATH, nowBook);
 
         MetricsUtil.INSTANCE.notifyChange(this.holder.config, this.holder.configPath);
-        if(TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE){
+        if (GuiSharedConstant.TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE) {
-            return holder.config.saveToDisk(TEMPORARY_DO_BACKUP_EVERY_SAVE);
+            return holder.config.saveToDisk(GuiSharedConstant.TEMPORARY_DO_BACKUP_EVERY_SAVE);
         }
         return true;
     }
@@ -220,27 +223,28 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
 
     /**
      * Create an int setting factory from setting's parameters.
-     * @param title The title of the gui.
+     *
-     * @param parent Parent gui to go back when completed.
+     * @param title          The title of the gui.
-     * @param configPath Configuration path of this setting.
+     * @param parent         Parent gui to go back when completed.
-     * @param config Configuration holder of this setting.
+     * @param configPath     Configuration path of this setting.
-     * @param min Minimum value of this setting.
+     * @param config         Configuration holder of this setting.
-     * @param max Maximum value of this setting.
+     * @param min            Minimum value of this setting.
+     * @param max            Maximum value of this setting.
      * @param defaultItemVal Default item value if not found on the config.
      * @param defaultBookVal Default book value if not found on the config.
-     * @param steps List of step the value can increment/decrement.
+     * @param steps          List of step the value can increment/decrement.
-     *              List's size should be between 1 (included) and 3 (included).
+     *                       List's size should be between 1 (included) and 3 (included).
-     *              it is visually preferable to have an odd number of step.
+     *                       it is visually preferable to have an odd number of step.
-     *              If step only contain 1 value, no step item should be displayed.
+     *                       If step only contain 1 value, no step item should be displayed.
      * @return A factory for an enchant cost setting gui.
      */
     public static EnchantCostSettingFactory enchantCostFactory(
             @NotNull String title, ValueUpdatableGui parent,
             String configPath, ConfigHolder config,
             int min, int max, int defaultItemVal, int defaultBookVal,
-            int... steps){
+            int... steps) {
         return new EnchantCostSettingFactory(
-                title,parent,
+                title, parent,
                 configPath, config,
                 min, max, defaultItemVal, defaultBookVal, steps);
     }
@@ -254,26 +258,27 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
 
         /**
          * Constructor for an enchantment cost setting gui factory.
-         * @param title The title of the gui.
+         *
-         * @param parent Parent gui to go back when completed.
+         * @param title          The title of the gui.
-         * @param configPath Configuration path of this setting.
+         * @param parent         Parent gui to go back when completed.
-         * @param config Configuration holder of this setting.
+         * @param configPath     Configuration path of this setting.
-         * @param min Minimum value of this setting.
+         * @param config         Configuration holder of this setting.
-         * @param max Maximum value of this setting.
+         * @param min            Minimum value of this setting.
+         * @param max            Maximum value of this setting.
          * @param defaultItemVal Default item value if not found on the config.
          * @param defaultBookVal Default book value if not found on the config.
-         * @param steps List of step the value can increment/decrement.
+         * @param steps          List of step the value can increment/decrement.
-         *              List's size should be between 1 (included) and 3 (included).
+         *                       List's size should be between 1 (included) and 3 (included).
-         *              it is visually preferable to have an odd number of step.
+         *                       it is visually preferable to have an odd number of step.
-         *              If step only contain 1 value, no step item should be displayed.
+         *                       If step only contain 1 value, no step item should be displayed.
          */
         protected EnchantCostSettingFactory(
                 @NotNull String title, ValueUpdatableGui parent,
                 String configPath, ConfigHolder config,
                 int min, int max, int defaultItemVal, int defaultBookVal,
-                int... steps){
+                int... steps) {
 
-            super(title,parent,
+            super(title, parent,
                     configPath, config,
                     min, max, defaultItemVal, steps);
             this.defaultBookVal = defaultBookVal;
@@ -284,14 +289,14 @@ public class EnchantCostSettingsGui extends IntSettingsGui {
          */
         @Override
         public int getConfiguredValue() {
-            return this.config.getConfig().getInt(this.configPath+ITEM_PATH, this.defaultVal);
+            return this.config.getConfig().getInt(this.configPath + ITEM_PATH, this.defaultVal);
         }
 
         /**
          * @return The configured value for the enchant setting book value.
          */
-        public int getConfiguredBookValue(){
+        public int getConfiguredBookValue() {
-            return this.config.getConfig().getInt(this.configPath+BOOK_PATH, this.defaultBookVal);
+            return this.config.getConfig().getInt(this.configPath + BOOK_PATH, this.defaultBookVal);
         }
 
         @Override

src/main/java/xyz/alexcrea/cuanvil/gui/config/settings/EnchantSelectSettingGui.java

@@ -0,0 +1,159 @@
+package xyz.alexcrea.cuanvil.gui.config.settings;
+
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
+import com.github.stefvanschie.inventoryframework.pane.Orientable;
+import com.github.stefvanschie.inventoryframework.pane.OutlinePane;
+import com.github.stefvanschie.inventoryframework.pane.Pane;
+import com.github.stefvanschie.inventoryframework.pane.util.Pattern;
+import io.delilaheve.CustomAnvil;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
+import xyz.alexcrea.cuanvil.gui.config.SelectEnchantmentContainer;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
+import xyz.alexcrea.cuanvil.util.CasedStringUtil;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class EnchantSelectSettingGui extends AbstractSettingGui {
+
+    SelectEnchantmentContainer enchantContainer;
+    int page;
+
+    Set<Enchantment> selectedEnchant;
+
+    public EnchantSelectSettingGui(@NotNull String title, ValueUpdatableGui parent, SelectEnchantmentContainer enchantContainer, int page) {
+        super(6, title, parent);
+        this.enchantContainer = enchantContainer;
+        // Not used and not planned rn
+        this.page = page;
+
+        this.selectedEnchant = new HashSet<>(enchantContainer.getSelectedEnchantments());
+
+        // Add secondary background item
+        this.getPane().bindItem('1', GuiSharedConstant.SECONDARY_BACKGROUND_ITEM);
+
+        initGroups();
+    }
+
+    @Override
+    protected Pattern getGuiPattern() {
+        return new Pattern(
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                "B1111111S"
+        );
+    }
+
+    protected void initGroups() {
+        // Add enchantment gui item
+        OutlinePane filledEnchant = new OutlinePane(0, 0, 9, 5);
+        filledEnchant.setPriority(Pane.Priority.HIGH);
+        filledEnchant.align(OutlinePane.Alignment.BEGIN);
+        filledEnchant.setOrientation(Orientable.Orientation.HORIZONTAL);
+
+        Set<Enchantment> illegalEnchant = this.enchantContainer.illegalEnchantments();
+        for (Enchantment enchant : GuiSharedConstant.SORTED_ENCHANTMENT_LIST) {
+            if (illegalEnchant.contains(enchant)) {
+                return;
+            }
+            filledEnchant.addItem(getGuiItemFromEnchant(enchant));
+        }
+
+        addPane(filledEnchant);
+
+    }
+
+    private GuiItem getGuiItemFromEnchant(Enchantment enchantment) {
+        boolean isIn = this.selectedEnchant.contains(enchantment);
+
+        Material usedMaterial;
+        if (isIn) {
+            usedMaterial = Material.ENCHANTED_BOOK;
+        } else {
+            usedMaterial = Material.BOOK;
+        }
+        ItemStack item = new ItemStack(usedMaterial);
+
+        setEnchantItemMeta(item, enchantment.getKey().getKey(), isIn);
+
+        GuiItem guiItem = new GuiItem(item, CustomAnvil.instance);
+        guiItem.setAction(getEnchantItemConsumer(enchantment, guiItem));
+        return guiItem;
+    }
+
+
+    private static final List<String> TRUE_LORE = Collections.singletonList("\u00A77Value: \u00A7aSelected");
+    private static final List<String> FALSE_LORE = Collections.singletonList("\u00A77Value: \u00A7cNot Selected");
+
+    public void setEnchantItemMeta(ItemStack item, String name, boolean isIn) {
+        ItemMeta meta = item.getItemMeta();
+
+        if (meta == null) {
+            CustomAnvil.instance.getLogger().warning("Could not create item for enchantment: " + name + ":\n" +
+                    "Item do not gave item meta: " + item + ". Using placeholder instead");
+            item.setType(Material.PAPER);
+            meta = item.getItemMeta();
+            assert meta != null;
+        }
+
+        meta.setDisplayName("\u00A7" + (isIn ? 'a' : 'c') + CasedStringUtil.snakeToUpperSpacedCase(name));
+        if (isIn) {
+            meta.addEnchant(Enchantment.DAMAGE_UNDEAD, 1, true);
+            meta.setLore(TRUE_LORE);
+        } else {
+            meta.removeEnchant(Enchantment.DAMAGE_UNDEAD);
+            meta.setLore(FALSE_LORE);
+        }
+        meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_ENCHANTS);
+
+        item.setItemMeta(meta);
+    }
+
+    private Consumer<InventoryClickEvent> getEnchantItemConsumer(Enchantment enchant, GuiItem guiItem) {
+        return event -> {
+            event.setCancelled(true);
+
+            ItemStack item = guiItem.getItem();
+
+            boolean isIn = this.selectedEnchant.contains(enchant);
+            if (isIn) {
+                this.selectedEnchant.remove(enchant);
+                item.setType(Material.BOOK);
+            } else {
+                this.selectedEnchant.add(enchant);
+                item.setType(Material.ENCHANTED_BOOK);
+            }
+
+            setEnchantItemMeta(item, enchant.getKey().getKey(), !isIn);
+            guiItem.setItem(item);// Just in case
+
+            update();
+        };
+    }
+
+    @Override
+    public boolean onSave() {
+        return this.enchantContainer.setSelectedEnchantments(this.selectedEnchant);
+    }
+
+    @Override
+    public boolean hadChange() {
+        Set<Enchantment> baseGroup = this.enchantContainer.getSelectedEnchantments();
+        return baseGroup.size() != this.selectedEnchant.size() ||
+                !baseGroup.containsAll(this.selectedEnchant);
+    }
+
+}

src/main/java/xyz/alexcrea/cuanvil/gui/config/settings/GroupSelectSettingGui.java

@@ -0,0 +1,152 @@
+package xyz.alexcrea.cuanvil.gui.config.settings;
+
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
+import com.github.stefvanschie.inventoryframework.pane.Orientable;
+import com.github.stefvanschie.inventoryframework.pane.OutlinePane;
+import com.github.stefvanschie.inventoryframework.pane.Pane;
+import com.github.stefvanschie.inventoryframework.pane.util.Pattern;
+import io.delilaheve.CustomAnvil;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import xyz.alexcrea.cuanvil.config.ConfigHolder;
+import xyz.alexcrea.cuanvil.group.AbstractMaterialGroup;
+import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
+import xyz.alexcrea.cuanvil.gui.config.SelectGroupContainer;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
+import xyz.alexcrea.cuanvil.util.CasedStringUtil;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class GroupSelectSettingGui extends AbstractSettingGui {
+
+    SelectGroupContainer groupContainer;
+    int page;
+
+    Set<AbstractMaterialGroup> selectedGroups;
+
+    public GroupSelectSettingGui(@NotNull String title, ValueUpdatableGui parent, SelectGroupContainer groupContainer, int page) {
+        super(6, title, parent);
+        this.groupContainer = groupContainer;
+        //Not used but planned
+        this.page = page;
+
+        this.selectedGroups = new HashSet<>(groupContainer.getSelectedGroups());
+
+        // Add secondary background item
+        this.getPane().bindItem('1', GuiSharedConstant.SECONDARY_BACKGROUND_ITEM);
+
+        initGroups();
+    }
+
+    @Override
+    protected Pattern getGuiPattern() {
+        return new Pattern(
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                "B1111111S"
+        );
+    }
+
+    protected void initGroups() {
+        // Add enchantment gui item
+        OutlinePane filledEnchant = new OutlinePane(0, 0, 9, 5);
+        filledEnchant.setPriority(Pane.Priority.HIGH);
+        filledEnchant.align(OutlinePane.Alignment.BEGIN);
+        filledEnchant.setOrientation(Orientable.Orientation.HORIZONTAL);
+
+        Set<AbstractMaterialGroup> illegalGroup = this.groupContainer.illegalGroups();
+        for (AbstractMaterialGroup group : ConfigHolder.ITEM_GROUP_HOLDER.getItemGroupsManager().getGroupMap().values()) {
+            if (illegalGroup.contains(group)) {
+                return;
+            }
+            filledEnchant.addItem(getGuiItemFromGroup(group));
+        }
+
+        addPane(filledEnchant);
+
+    }
+
+    private GuiItem getGuiItemFromGroup(AbstractMaterialGroup group) {
+        boolean isIn = this.selectedGroups.contains(group);
+
+        Material usedMaterial = group.getRepresentativeMaterial();
+        ItemStack item = new ItemStack(usedMaterial);
+
+        setGroupItemMeta(item, group.getName(), isIn);
+
+        GuiItem guiItem = new GuiItem(item, CustomAnvil.instance);
+        guiItem.setAction(getGroupItemConsumer(group, guiItem));
+        return guiItem;
+    }
+
+    private static final List<String> TRUE_LORE = Collections.singletonList("\u00A77Value: \u00A7aSelected");
+    private static final List<String> FALSE_LORE = Collections.singletonList("\u00A77Value: \u00A7cNot Selected");
+
+    public void setGroupItemMeta(ItemStack item, String name, boolean isIn) {
+        ItemMeta meta = item.getItemMeta();
+
+        if (meta == null) {
+            CustomAnvil.instance.getLogger().warning("Could not create item for group: " + name + ":\n" +
+                    "Item do not gave item meta: " + item + ". Using placeholder instead");
+            item.setType(Material.PAPER);
+            meta = item.getItemMeta();
+            assert meta != null;
+        }
+
+        meta.setDisplayName("\u00A7" + (isIn ? 'a' : 'c') + CasedStringUtil.snakeToUpperSpacedCase(name));
+        if (isIn) {
+            meta.addEnchant(Enchantment.DAMAGE_UNDEAD, 1, true);
+            meta.setLore(TRUE_LORE);
+        } else {
+            meta.removeEnchant(Enchantment.DAMAGE_UNDEAD);
+            meta.setLore(FALSE_LORE);
+        }
+        meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_ENCHANTS);
+
+        item.setItemMeta(meta);
+    }
+
+    private Consumer<InventoryClickEvent> getGroupItemConsumer(AbstractMaterialGroup group, GuiItem guiItem) {
+        return event -> {
+            event.setCancelled(true);
+
+            boolean isIn = this.selectedGroups.contains(group);
+            if (isIn) {
+                this.selectedGroups.remove(group);
+            } else {
+                this.selectedGroups.add(group);
+            }
+
+            ItemStack item = guiItem.getItem();
+            setGroupItemMeta(item, group.getName(), !isIn);
+            guiItem.setItem(item);// Just in case
+
+            update();
+        };
+    }
+
+    @Override
+    public boolean onSave() {
+        return this.groupContainer.setSelectedGroups(this.selectedGroups);
+    }
+
+    @Override
+    public boolean hadChange() {
+        Set<AbstractMaterialGroup> baseGroup = this.groupContainer.getSelectedGroups();
+        return baseGroup.size() != this.selectedGroups.size() ||
+                !baseGroup.containsAll(this.selectedGroups);
+    }
+
+}

src/main/java/xyz/alexcrea/cuanvil/gui/config/settings/IntSettingsGui.java

@@ -13,6 +13,7 @@ import xyz.alexcrea.cuanvil.config.ConfigHolder;
 import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions;
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
 import xyz.alexcrea.cuanvil.util.MetricsUtil;
 
 import java.util.Collections;
@@ -22,7 +23,7 @@ import java.util.function.Consumer;
 /**
  * An instance of a gui used to edit an int setting.
  */
-public class IntSettingsGui extends AbstractSettingGui{
+public class IntSettingsGui extends AbstractSettingGui {
 
     protected final IntSettingFactory holder;
     protected final int before;
@@ -31,8 +32,9 @@ public class IntSettingsGui extends AbstractSettingGui{
 
     /**
      * Create an int setting config gui.
+     *
      * @param holder Configuration factory of this setting.
-     * @param now The defined value of this setting.
+     * @param now    The defined value of this setting.
      */
     protected IntSettingsGui(IntSettingFactory holder, int now) {
         super(3, holder.getTitle(), holder.parent);
@@ -58,43 +60,44 @@ public class IntSettingsGui extends AbstractSettingGui{
     }
 
     protected GuiItem returnToDefault;
+
     /**
      * Prepare "return to default value" gui item.
      */
-    protected void prepareReturnToDefault(){
+    protected void prepareReturnToDefault() {
         ItemStack item = new ItemStack(Material.COMMAND_BLOCK);
         ItemMeta meta = item.getItemMeta();
 
         meta.setDisplayName("\u00A7eReset to default value");
-        meta.setLore(Collections.singletonList("\u00A77Default value is: "+holder.defaultVal));
+        meta.setLore(Collections.singletonList("\u00A77Default value is: " + holder.defaultVal));
         item.setItemMeta(meta);
         returnToDefault = new GuiItem(item, event -> {
             event.setCancelled(true);
             now = holder.defaultVal;
             updateValueDisplay();
             update();
-            }, CustomAnvil.instance);
+        }, CustomAnvil.instance);
     }
 
     /**
      * Update item using the setting value to match the new value.
      */
-    protected void updateValueDisplay(){
+    protected void updateValueDisplay() {
 
         PatternPane pane = getPane();
 
         // minus item
         GuiItem minusItem;
-        if(now > holder.min){
+        if (now > holder.min) {
             int planned = Math.max(holder.min, now - step);
             ItemStack item = new ItemStack(Material.RED_TERRACOTTA);
             ItemMeta meta = item.getItemMeta();
-            meta.setDisplayName("\u00A7e"+now+" -> "+planned + " \u00A7r(\u00A7c-"+(now-planned)+"\u00A7r)");
+            meta.setDisplayName("\u00A7e" + now + " -> " + planned + " \u00A7r(\u00A7c-" + (now - planned) + "\u00A7r)");
             meta.setLore(AbstractSettingGui.CLICK_LORE);
             item.setItemMeta(meta);
 
             minusItem = new GuiItem(item, updateNowConsumer(planned), CustomAnvil.instance);
-        }else{
+        } else {
             minusItem = GuiGlobalItems.backgroundItem(Material.BARRIER);
         }
         pane.bindItem('-', minusItem);
@@ -102,16 +105,16 @@ public class IntSettingsGui extends AbstractSettingGui{
         //plus item
         // may do a function to generalise ?
         GuiItem plusItem;
-        if(now < holder.max){
+        if (now < holder.max) {
             int planned = Math.min(holder.max, now + step);
             ItemStack item = new ItemStack(Material.GREEN_TERRACOTTA);
             ItemMeta meta = item.getItemMeta();
-            meta.setDisplayName("\u00A7e"+now+" -> "+planned + " \u00A7r(\u00A7a+"+(planned-now)+"\u00A7r)");
+            meta.setDisplayName("\u00A7e" + now + " -> " + planned + " \u00A7r(\u00A7a+" + (planned - now) + "\u00A7r)");
             meta.setLore(AbstractSettingGui.CLICK_LORE);
             item.setItemMeta(meta);
 
             plusItem = new GuiItem(item, updateNowConsumer(planned), CustomAnvil.instance);
-        }else{
+        } else {
             plusItem = GuiGlobalItems.backgroundItem(Material.BARRIER);
         }
         pane.bindItem('+', plusItem);
@@ -119,7 +122,7 @@ public class IntSettingsGui extends AbstractSettingGui{
         // "result" display
         ItemStack resultPaper = new ItemStack(Material.PAPER);
         ItemMeta resultMeta = resultPaper.getItemMeta();
-        resultMeta.setDisplayName("\u00A7eValue: "+now);
+        resultMeta.setDisplayName("\u00A7eValue: " + now);
         resultPaper.setItemMeta(resultMeta);
         GuiItem resultItem = new GuiItem(resultPaper, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
 
@@ -127,9 +130,9 @@ public class IntSettingsGui extends AbstractSettingGui{
 
         // reset to default
         GuiItem returnToDefault;
-        if(now != holder.defaultVal){
+        if (now != holder.defaultVal) {
             returnToDefault = this.returnToDefault;
-        }else{
+        } else {
             returnToDefault = GuiGlobalItems.backgroundItem();
         }
         pane.bindItem('D', returnToDefault);
@@ -141,8 +144,8 @@ public class IntSettingsGui extends AbstractSettingGui{
      * @param planned Value to change current setting to.
      * @return A consumer to update the current setting's value.
      */
-    protected Consumer<InventoryClickEvent> updateNowConsumer(int planned){
+    protected Consumer<InventoryClickEvent> updateNowConsumer(int planned) {
-        return event->{
+        return event -> {
             event.setCancelled(true);
             now = planned;
             updateValueDisplay();
@@ -153,12 +156,12 @@ public class IntSettingsGui extends AbstractSettingGui{
     /**
      * Initialise step items.
      */
-    protected void initStepsValue(){
+    protected void initStepsValue() {
         // Put background glass on the background of 'a' to 'b'
         GuiItem background = GuiGlobalItems.backgroundItem();
         PatternPane pane = getPane();
 
-        for (char i = 'a'; i < (getMidStepChar()-'a')*2+1; i++) {
+        for (char i = 'a'; i < (getMidStepChar() - 'a') * 2 + 1; i++) {
             pane.bindItem(i, background);
         }
         // Then update legit step values
@@ -168,35 +171,37 @@ public class IntSettingsGui extends AbstractSettingGui{
     /**
      * Update steps items value.
      */
-    protected void updateStepValue(){
+    protected void updateStepValue() {
-        if(holder.steps.length <= 1) return;
+        if (holder.steps.length <= 1) return;
         // We assume steps have a length of 2k+1 cause its more pretty
         char val = getMidStepChar();
         // Offset to start (not the best way to do it)
-        val -= (char) ((holder.steps.length-1)/2);
+        val -= (char) ((holder.steps.length - 1) / 2);
 
         // Then place items
         PatternPane pane = getPane();
         for (int i = 0; i < holder.steps.length; i++) {
-            pane.bindItem(val+i, stepGuiItem(i));
+            pane.bindItem(val + i, stepGuiItem(i));
         }
 
     }
 
     /**
      * Step use lower case character from 'a' to a certain char.
+     *
      * @return The middle value of the character set for steps.
      */
-    protected char getMidStepChar(){
+    protected char getMidStepChar() {
         return 'e';
     }
 
     /**
      * Create a step item from a step value.
+     *
      * @param stepIndex the index of the step item.
      * @return A step item corresponding to its index value.
      */
-    protected GuiItem stepGuiItem(int stepIndex){
+    protected GuiItem stepGuiItem(int stepIndex) {
         int stepValue = holder.steps[stepIndex];
 
         // Get material properties
@@ -204,15 +209,15 @@ public class IntSettingsGui extends AbstractSettingGui{
         StringBuilder stepName = new StringBuilder("\u00A7");
         List<String> stepLore;
         Consumer<InventoryClickEvent> clickEvent;
-        if(stepValue == step){
+        if (stepValue == step) {
             stepMat = Material.GREEN_STAINED_GLASS_PANE;
             stepName.append('a');
-            stepLore = Collections.singletonList("\u00A77Value is changing by "+stepValue);
+            stepLore = Collections.singletonList("\u00A77Value is changing by " + stepValue);
             clickEvent = GuiGlobalActions.stayInPlace;
-        }else{
+        } else {
             stepMat = Material.RED_STAINED_GLASS_PANE;
             stepName.append('c');
-            stepLore = Collections.singletonList("\u00A77Click here to change the value by "+stepValue);
+            stepLore = Collections.singletonList("\u00A77Click here to change the value by " + stepValue);
             clickEvent = updateStepValue(stepValue);
         }
         stepName.append("Step of: ").append(stepValue);
@@ -232,7 +237,7 @@ public class IntSettingsGui extends AbstractSettingGui{
      * @param stepValue Value to change current step to.
      * @return A consumer to update the current step of this setting.
      */
-    protected Consumer<InventoryClickEvent> updateStepValue(int stepValue){
+    protected Consumer<InventoryClickEvent> updateStepValue(int stepValue) {
         return event -> {
             event.setCancelled(true);
             this.step = stepValue;
@@ -247,8 +252,8 @@ public class IntSettingsGui extends AbstractSettingGui{
         holder.config.getConfig().set(holder.configPath, now);
 
         MetricsUtil.INSTANCE.notifyChange(this.holder.config, this.holder.configPath);
-        if(TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE){
+        if (GuiSharedConstant.TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE) {
-            return holder.config.saveToDisk(TEMPORARY_DO_BACKUP_EVERY_SAVE);
+            return holder.config.saveToDisk(GuiSharedConstant.TEMPORARY_DO_BACKUP_EVERY_SAVE);
         }
         return true;
     }
@@ -260,24 +265,25 @@ public class IntSettingsGui extends AbstractSettingGui{
 
     /**
      * Create an int setting factory from setting's parameters.
-     * @param title The title of the gui.
+     *
-     * @param parent Parent gui to go back when completed.
+     * @param title      The title of the gui.
+     * @param parent     Parent gui to go back when completed.
      * @param configPath Configuration path of this setting.
-     * @param config Configuration holder of this setting.
+     * @param config     Configuration holder of this setting.
-     * @param min Minimum value of this setting.
+     * @param min        Minimum value of this setting.
-     * @param max Maximum value of this setting.
+     * @param max        Maximum value of this setting.
      * @param defaultVal Default value if not found on the config.
-     * @param steps List of step the value can increment/decrement.
+     * @param steps      List of step the value can increment/decrement.
-     *              List's size should be between 1 (included) and 5 (included).
+     *                   List's size should be between 1 (included) and 5 (included).
-     *              it is visually preferable to have an odd number of step.
+     *                   it is visually preferable to have an odd number of step.
-     *              If step only contain 1 value, no step item should be displayed.
+     *                   If step only contain 1 value, no step item should be displayed.
      * @return A factory for an int setting gui.
      */
     public static IntSettingFactory intFactory(@NotNull String title, ValueUpdatableGui parent,
                                                String configPath, ConfigHolder config,
-                                               int min, int max, int defaultVal, int... steps){
+                                               int min, int max, int defaultVal, int... steps) {
         return new IntSettingFactory(
-                title,parent,
+                title, parent,
                 configPath, config,
                 min, max, defaultVal, steps);
     }
@@ -285,28 +291,34 @@ public class IntSettingsGui extends AbstractSettingGui{
     /**
      * A factory for an int setting gui that hold setting's information.
      */
-    public static class IntSettingFactory extends SettingGuiFactory{
+    public static class IntSettingFactory extends SettingGuiFactory {
-        @NotNull String title; ValueUpdatableGui parent;
+        @NotNull
-        int min; int max; int defaultVal; int[] steps;
+        String title;
+        ValueUpdatableGui parent;
+        int min;
+        int max;
+        int defaultVal;
+        int[] steps;
 
         /**
          * Constructor for an int setting gui factory.
-         * @param title The title of the gui.
+         *
-         * @param parent Parent gui to go back when completed.
+         * @param title      The title of the gui.
+         * @param parent     Parent gui to go back when completed.
          * @param configPath Configuration path of this setting.
-         * @param config Configuration holder of this setting.
+         * @param config     Configuration holder of this setting.
-         * @param min Minimum value of this setting.
+         * @param min        Minimum value of this setting.
-         * @param max Maximum value of this setting.
+         * @param max        Maximum value of this setting.
          * @param defaultVal Default value if not found on the config.
-         * @param steps List of step the value can increment/decrement.
+         * @param steps      List of step the value can increment/decrement.
-         *              List's size should be between 1 (included) and 5 (included).
+         *                   List's size should be between 1 (included) and 5 (included).
-         *              it is visually preferable to have an odd number of step.
+         *                   it is visually preferable to have an odd number of step.
-         *              If step only contain 1 value, no step item should be displayed.
+         *                   If step only contain 1 value, no step item should be displayed.
          */
         protected IntSettingFactory(
                 @NotNull String title, ValueUpdatableGui parent,
                 String configPath, ConfigHolder config,
-                int min, int max, int defaultVal, int... steps){
+                int min, int max, int defaultVal, int... steps) {
             super(configPath, config);
             this.title = title;
             this.parent = parent;
@@ -327,7 +339,7 @@ public class IntSettingsGui extends AbstractSettingGui{
         /**
          * @return The configured value for the associated setting.
          */
-        public int getConfiguredValue(){
+        public int getConfiguredValue() {
             return this.config.getConfig().getInt(this.configPath, this.defaultVal);
         }
 

src/main/java/xyz/alexcrea/cuanvil/gui/config/settings/subsetting/EnchantConflictSubSettingGui.java

@@ -0,0 +1,350 @@
+package xyz.alexcrea.cuanvil.gui.config.settings.subsetting;
+
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
+import com.github.stefvanschie.inventoryframework.pane.PatternPane;
+import com.github.stefvanschie.inventoryframework.pane.util.Pattern;
+import io.delilaheve.CustomAnvil;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import xyz.alexcrea.cuanvil.config.ConfigHolder;
+import xyz.alexcrea.cuanvil.group.AbstractMaterialGroup;
+import xyz.alexcrea.cuanvil.group.EnchantConflictGroup;
+import xyz.alexcrea.cuanvil.group.EnchantConflictManager;
+import xyz.alexcrea.cuanvil.gui.ValueUpdatableGui;
+import xyz.alexcrea.cuanvil.gui.config.ConfirmActionGui;
+import xyz.alexcrea.cuanvil.gui.config.SelectEnchantmentContainer;
+import xyz.alexcrea.cuanvil.gui.config.SelectGroupContainer;
+import xyz.alexcrea.cuanvil.gui.config.global.EnchantConflictGui;
+import xyz.alexcrea.cuanvil.gui.config.settings.EnchantSelectSettingGui;
+import xyz.alexcrea.cuanvil.gui.config.settings.GroupSelectSettingGui;
+import xyz.alexcrea.cuanvil.gui.config.settings.IntSettingsGui;
+import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions;
+import xyz.alexcrea.cuanvil.gui.util.GuiGlobalItems;
+import xyz.alexcrea.cuanvil.gui.util.GuiSharedConstant;
+import xyz.alexcrea.cuanvil.util.CasedStringUtil;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+public class EnchantConflictSubSettingGui extends ValueUpdatableGui implements SelectEnchantmentContainer, SelectGroupContainer {
+
+    private final EnchantConflictGui parent;
+    private final EnchantConflictGroup enchantConflict;
+    private final GuiItem parentItemForThisGui;
+    private final PatternPane pane;
+    private boolean shouldWorld = true;
+
+    public EnchantConflictSubSettingGui(
+            @NotNull EnchantConflictGui parent,
+            @NotNull EnchantConflictGroup enchantConflict,
+            @NotNull GuiItem parentItemForThisGui) {
+        super(3,
+                "\u00A7e" + CasedStringUtil.snakeToUpperSpacedCase(enchantConflict.getName()) + " \u00A78Config",
+                CustomAnvil.instance);
+        this.parent = parent;
+        this.enchantConflict = enchantConflict;
+        this.parentItemForThisGui = parentItemForThisGui;
+
+        Pattern pattern = new Pattern(
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                "00EGM000D",
+                "B00000000"
+        );
+        this.pane = new PatternPane(0, 0, 9, 3, pattern);
+        addPane(this.pane);
+
+        prepareStaticValues();
+    }
+
+    private GuiItem enchantSettingItem;
+    private GuiItem groupSettingItem;
+    private IntSettingsGui.IntSettingFactory minBeforeActiveSettingFactory;
+
+    private void prepareStaticValues() {
+
+        GuiGlobalItems.addBackItem(this.pane, this.parent);
+        GuiGlobalItems.addBackgroundItem(this.pane);
+
+        // Delete item
+        ItemStack deleteItem = new ItemStack(Material.RED_TERRACOTTA);
+        ItemMeta deleteMeta = deleteItem.getItemMeta();
+
+        deleteMeta.setDisplayName("\u00A74DELETE CONFLICT");
+        deleteMeta.setLore(Collections.singletonList("\u00A7cCaution with this button !"));
+
+        deleteItem.setItemMeta(deleteMeta);
+        this.pane.bindItem('D', new GuiItem(deleteItem, GuiGlobalActions.openGuiAction(createDeleteGui()), CustomAnvil.instance));
+
+        // Displayed item will be updated later
+
+        this.enchantSettingItem = new GuiItem(new ItemStack(Material.ENCHANTED_BOOK), (event) -> {
+            event.setCancelled(true);
+            EnchantSelectSettingGui enchantGui = new EnchantSelectSettingGui(
+                    "\u00A7e" + CasedStringUtil.snakeToUpperSpacedCase(enchantConflict.getName()) + " \u00A75Enchantments",
+                    this, this, 0);
+            enchantGui.show(event.getWhoClicked());
+        }, CustomAnvil.instance);
+
+        this.groupSettingItem = new GuiItem(new ItemStack(Material.PAPER), (event) -> {
+            event.setCancelled(true);
+            GroupSelectSettingGui enchantGui = new GroupSelectSettingGui(
+                    "\u00A7e" + CasedStringUtil.snakeToUpperSpacedCase(this.enchantConflict.getName()) + " \u00A73Groups",
+                    this, this, 0);
+            enchantGui.show(event.getWhoClicked());
+        }, CustomAnvil.instance);
+
+        this.minBeforeActiveSettingFactory = IntSettingsGui.intFactory(
+                "\u00A78Minimum enchantment count",
+                this, this.enchantConflict.getName() + ".maxEnchantmentBeforeConflict", ConfigHolder.CONFLICT_HOLDER,
+                0, 255, 0, 1
+        );
+
+        this.pane.bindItem('E', this.enchantSettingItem);
+        this.pane.bindItem('G', this.groupSettingItem);
+
+        // Now we update the items
+        updateLocal();
+
+    }
+
+    private ConfirmActionGui createDeleteGui() {
+        Supplier<Boolean> deleteSupplier = () -> {
+            EnchantConflictManager manager = ConfigHolder.CONFLICT_HOLDER.getConflictManager();
+
+            // Remove from manager
+            for (Enchantment enchantment : this.enchantConflict.getEnchants()) {
+                manager.removeConflictFromMap(enchantment, this.enchantConflict);
+            }
+            manager.conflictList.remove(this.enchantConflict);
+
+            // Remove from parent
+            this.parent.removeConflict(this.enchantConflict);
+
+            // Remove self
+            cleanUnused();
+
+            // Update config file storage
+            ConfigHolder.CONFLICT_HOLDER.getConfig().set(this.enchantConflict.getName(), null);
+
+            // Save
+            boolean success = true;
+            if (GuiSharedConstant.TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE) {
+                success = ConfigHolder.CONFLICT_HOLDER.saveToDisk(GuiSharedConstant.TEMPORARY_DO_BACKUP_EVERY_SAVE);
+            }
+
+            return success;
+        };
+
+        return new ConfirmActionGui("\u00A7cDelete \u00A7e" + CasedStringUtil.snakeToUpperSpacedCase(enchantConflict.getName()) + "\u00A7c?",
+                "\u00A77Confirm that you want to delete this conflict.",
+                this, this.parent, deleteSupplier
+        );
+    }
+
+    @Override
+    public void updateGuiValues() {
+        this.parent.updateValueForConflict(this.enchantConflict, true);
+        // Parent should call updateLocal
+    }
+
+    public void updateLocal() {
+        if (!this.shouldWorld) return;
+
+        // Prepare enchantment lore
+        ArrayList<String> enchantLore = new ArrayList<>();
+        enchantLore.add("\u00A77Allow you to select a list of \u00A75Enchantments \u00A77that this conflict should include");
+        Set<Enchantment> enchants = getSelectedEnchantments();
+        if (enchants.isEmpty()) {
+            enchantLore.add("\u00A77There is no included enchantment for this conflict.");
+        } else {
+            enchantLore.add("\u00A77List of included enchantment for this conflict:");
+            Iterator<Enchantment> enchantIterator = enchants.iterator();
+
+            boolean greaterThanMax = enchants.size() > 5;
+            int maxindex = (greaterThanMax ? 4 : enchants.size());
+            for (int i = 0; i < maxindex; i++) {
+                // format string like "- Fire Protection"
+                String formattedName = CasedStringUtil.snakeToUpperSpacedCase(enchantIterator.next().getKey().getKey());
+                enchantLore.add("\u00A77- \u00A75" + formattedName);
+            }
+            if (greaterThanMax) {
+                enchantLore.add("\u00A77And " + (enchants.size() - 4) + " more...");
+            }
+
+        }
+
+        // Prepare group lore
+        ArrayList<String> groupLore = new ArrayList<>();
+        groupLore.add("\u00A77Allow you to select a list of \u00A73Groups \u00A77that this conflict should include");
+        Set<AbstractMaterialGroup> grouos = getSelectedGroups();
+        if (grouos.isEmpty()) {
+            groupLore.add("\u00A77There is no excluded groups for this conflict.");
+        } else {
+            groupLore.add("\u00A77List of excluded groups for this conflict:");
+            Iterator<AbstractMaterialGroup> groupIterator = grouos.iterator();
+
+            boolean greaterThanMax = grouos.size() > 5;
+            int maxindex = (greaterThanMax ? 4 : grouos.size());
+            for (int i = 0; i < maxindex; i++) {
+                // format string like "- Melee Weapons"
+                String formattedName = CasedStringUtil.snakeToUpperSpacedCase(groupIterator.next().getName());
+                groupLore.add("\u00A77- \u00A73" + formattedName);
+
+            }
+            if (greaterThanMax) {
+                groupLore.add("\u00A77And " + (grouos.size() - 4) + " more...");
+            }
+        }
+
+        // Configure enchant setting item
+        ItemStack enchantItem = this.enchantSettingItem.getItem();
+        ItemMeta enchantMeta = enchantItem.getItemMeta();
+
+        enchantMeta.setDisplayName("\u00A7aSelect included \u00A75Enchantments \u00A7aSettings");
+        enchantMeta.setLore(enchantLore);
+
+        enchantItem.setItemMeta(enchantMeta);
+
+        this.enchantSettingItem.setItem(enchantItem); // Just in case
+
+        // Configure group setting item
+        ItemStack groupItem = this.groupSettingItem.getItem();
+        ItemMeta groupMeta = groupItem.getItemMeta();
+
+        groupMeta.setDisplayName("\u00A7aSelect excluded \u00A73Groups \u00A7aSettings");
+        groupMeta.setLore(groupLore);
+
+        groupItem.setItemMeta(groupMeta);
+
+        this.groupSettingItem.setItem(groupItem); // Just in case
+
+
+        this.pane.bindItem('M', GuiGlobalItems.intSettingGuiItem(this.minBeforeActiveSettingFactory, Material.COMMAND_BLOCK));
+        update();
+    }
+
+    public void cleanUnused() {
+        for (HumanEntity viewer : getViewers()) {
+            this.parent.show(viewer);
+        }
+        this.shouldWorld = false;
+
+        // Just in case something is extremely wrong
+        GuiItem background = GuiGlobalItems.backgroundItem();
+        this.pane.bindItem('E', background);
+        this.pane.bindItem('G', background);
+        this.pane.bindItem('M', background);
+        this.pane.bindItem('D', background);
+    }
+
+    @Override
+    public void show(@NotNull HumanEntity humanEntity) {
+        if (this.shouldWorld) {
+            super.show(humanEntity);
+        } else {
+            this.parent.show(humanEntity);
+        }
+    }
+
+    public GuiItem getParentItemForThisGui() {
+        return parentItemForThisGui;
+    }
+
+    // Select enchantment container methods
+
+    @Override
+    public Set<Enchantment> getSelectedEnchantments() {
+        return this.enchantConflict.getEnchants();
+    }
+
+    @Override
+    public boolean setSelectedEnchantments(Set<Enchantment> enchantments) {
+        if (!this.shouldWorld) {
+            CustomAnvil.instance.getLogger().info("Trying to save " + enchantConflict.getName() + " enchants but sub config is destroyed");
+            return false;
+        }
+
+        // Set live configuration
+        this.enchantConflict.setEnchants(enchantments);
+
+        // Save on file configuration
+        String[] enchantKeys = new String[enchantments.size()];
+        int index = 0;
+        for (Enchantment enchantment : enchantments) {
+            enchantKeys[index++] = enchantment.getKey().getKey();
+        }
+        ConfigHolder.CONFLICT_HOLDER.getConfig().set(enchantConflict.getName() + ".enchantments", enchantKeys);
+
+        try {
+            updateGuiValues();
+        } catch (Exception e) {
+            CustomAnvil.instance.getLogger().log(Level.WARNING, "An error occurred while updating enchants for " + this.enchantConflict.getName(), e);
+        }
+
+
+        // Save file configuration to disk
+        if (GuiSharedConstant.TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE) {
+            return ConfigHolder.CONFLICT_HOLDER.saveToDisk(GuiSharedConstant.TEMPORARY_DO_BACKUP_EVERY_SAVE);
+        }
+
+        return true;
+    }
+
+    @Override
+    public Set<Enchantment> illegalEnchantments() {
+        return Collections.emptySet();
+    }
+
+    // Select group container methods
+
+    @Override
+    public Set<AbstractMaterialGroup> getSelectedGroups() {
+        return this.enchantConflict.getCantConflictGroup().getGroups();
+    }
+
+    @Override
+    public boolean setSelectedGroups(Set<AbstractMaterialGroup> groups) {
+        if (!this.shouldWorld) {
+            CustomAnvil.instance.getLogger().info("Trying to save " + enchantConflict.getName() + " groups but sub config is destroyed");
+            return false;
+        }
+
+        // Set live configuration
+        this.enchantConflict.getCantConflictGroup().setGroups(groups);
+
+        // Save on file configuration
+        String[] groupsNames = new String[groups.size()];
+        int index = 0;
+        for (AbstractMaterialGroup group : groups) {
+            groupsNames[index++] = group.getName();
+        }
+        ConfigHolder.CONFLICT_HOLDER.getConfig().set(this.enchantConflict.getName() + ".notAffectedGroups", groupsNames);
+
+        try {
+            updateGuiValues();
+        } catch (Exception e) {
+            CustomAnvil.instance.getLogger().log(Level.WARNING, "An error occurred while updating group for " + this.enchantConflict.getName(), e);
+        }
+
+        // Save file configuration to disk
+        if (GuiSharedConstant.TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE) {
+            return ConfigHolder.CONFLICT_HOLDER.saveToDisk(GuiSharedConstant.TEMPORARY_DO_BACKUP_EVERY_SAVE);
+        }
+
+        return true;
+    }
+
+    @Override
+    public Set<AbstractMaterialGroup> illegalGroups() {
+
+        return Collections.emptySet();
+    }
+}

src/main/java/xyz/alexcrea/cuanvil/gui/util/GuiGlobalActions.java

@@ -27,21 +27,22 @@ public class GuiGlobalActions {
     /**
      * Create a consumer to create and open a new GUI.
      * Used with InventoryClickEvent as the consumer argument as it is planned to be used on click on an GuiItem.
-     * @param clazz The class of the gui to open.
+     *
-     *              It is assumed this class contain a constructor requiring arguments of argClass in the same order as argClass array.
+     * @param clazz    The class of the gui to open.
+     *                 It is assumed this class contain a constructor requiring arguments of argClass in the same order as argClass array.
      * @param argClass Classes of the argument that will be passed to the constructor of the GUI class.
-     * @param args Arguments for the constructor the GUI class.
+     * @param args     Arguments for the constructor the GUI class.
      * @return A consumer to create a new gui and open it.
      */
     public static @NotNull Consumer<InventoryClickEvent> openGuiAction(
             @NotNull Class<? extends Gui> clazz,
             @NotNull Class<?>[] argClass,
-            @NotNull Object... args){
+            @NotNull Object... args) {
         return event -> {
             event.setCancelled(true);
             HumanEntity player = event.getWhoClicked();
             // Do not allow to open inventory if player do not have edit configuration permission
-            if(!player.hasPermission(CustomAnvil.editConfigPermission)) {
+            if (!player.hasPermission(CustomAnvil.editConfigPermission)) {
                 player.closeInventory();
                 player.sendMessage(NO_EDIT_PERM);
                 return;
@@ -62,22 +63,24 @@ public class GuiGlobalActions {
     /**
      * Create a consumer to create and open a new GUI.
      * Used with InventoryClickEvent as the consumer argument as it is planned to be used on click on an GuiItem.
+     *
      * @param clazz The class of the gui to open.
      *              It is assumed this class contain a constructor with no argument.
      * @return A consumer to create a new gui and open it.
      */
     public static @NotNull Consumer<InventoryClickEvent> openGuiAction(
-            @NotNull Class<? extends Gui> clazz){
+            @NotNull Class<? extends Gui> clazz) {
         return openGuiAction(clazz, new Class<?>[0]);
     }
 
     /**
      * Create a consumer to open a setting gui from a setting GUI factory.
      * Used with InventoryClickEvent as the consumer argument as it is planned to be used on click on an GuiItem.
+     *
      * @param factory The setting gui factory.
      * @return A consumer to create and open a new setting GUI.
      */
-    public static @NotNull Consumer<InventoryClickEvent> openSettingGuiAction(AbstractSettingGui.SettingGuiFactory factory){
+    public static @NotNull Consumer<InventoryClickEvent> openSettingGuiAction(AbstractSettingGui.SettingGuiFactory factory) {
         return event -> {
             event.setCancelled(true);
             Gui gui = factory.create();
@@ -88,6 +91,7 @@ public class GuiGlobalActions {
     /**
      * Create a consumer to open a global GUI.
      * Used with InventoryClickEvent as the consumer argument as it is planned to be used on click on an GuiItem.
+     *
      * @param goal The gui to open when consumer is run.
      * @return A consumer to open a global GUI.
      */
@@ -95,7 +99,7 @@ public class GuiGlobalActions {
         return event -> {
             HumanEntity player = event.getWhoClicked();
             // Do not allow to open inventory if player do not have edit configuration permission
-            if(!player.hasPermission(CustomAnvil.editConfigPermission)) {
+            if (!player.hasPermission(CustomAnvil.editConfigPermission)) {
                 player.closeInventory();
                 player.sendMessage(NO_EDIT_PERM);
                 return;
@@ -109,8 +113,9 @@ public class GuiGlobalActions {
      * Create a consumer to update and open an updatable GUI.
      * Used with InventoryClickEvent as the consumer argument as it is planned to be used on click on an GuiItem.
      * This consumer check if the player who interacted with the item have the permission to save before saving.
+     *
      * @param setting The gui that contain the modified setting.
-     * @param goal The gui to update and open when consumer is run.
+     * @param goal    The gui to update and open when consumer is run.
      * @return A consumer to open a global GUI.
      */
     public static @NotNull Consumer<InventoryClickEvent> saveSettingAction(
@@ -120,14 +125,14 @@ public class GuiGlobalActions {
             event.setCancelled(true);
             HumanEntity player = event.getWhoClicked();
             // Do not allow to save configuration if player do not have edit configuration permission
-            if(!player.hasPermission(CustomAnvil.editConfigPermission)) {
+            if (!player.hasPermission(CustomAnvil.editConfigPermission)) {
                 player.closeInventory();
                 player.sendMessage(NO_EDIT_PERM);
                 return;
             }
 
             // Save setting
-            if(!setting.onSave()){
+            if (!setting.onSave()) {
                 player.sendMessage("\u00A7cSomething went wrong while saving the change of value.");
             }
             // Update gui for those who have it open.

src/main/java/xyz/alexcrea/cuanvil/gui/util/GuiGlobalItems.java

@@ -23,6 +23,7 @@ public class GuiGlobalItems {
 
     // statically create default back itemstack
     private static final ItemStack BACK_ITEM;
+
     static {
         BACK_ITEM = new ItemStack(Material.BARRIER);
         ItemMeta meta = BACK_ITEM.getItemMeta();
@@ -32,32 +33,35 @@ public class GuiGlobalItems {
 
     /**
      * Create a GuiItem that open the given GUi.
+     *
      * @param item The item to display in the GUI.
      * @param goal The GUI to open on click.
      * @return An GuiItem that open goal on click.
      */
-    public static GuiItem goToGuiItem(@NotNull ItemStack item, @NotNull Gui goal){
+    public static GuiItem goToGuiItem(@NotNull ItemStack item, @NotNull Gui goal) {
         return new GuiItem(item, GuiGlobalActions.openGuiAction(goal), CustomAnvil.instance);
     }
 
     /**
      * Create back button item from default back GuiItem.
      * The back item will open the goal inventory when clicked.
+     *
      * @param goal The GUI to go back to.
      * @return An GuiItem that go back to goal on click.
      */
-    public static GuiItem backItem(@NotNull Gui goal){
+    public static GuiItem backItem(@NotNull Gui goal) {
         return goToGuiItem(BACK_ITEM, goal);
     }
 
     /**
      * Add default back item to a GUI pattern with the reserved character key <strong>B</strong>.
      * The back item will open the target inventory when clicked.
+     *
      * @param target The pattern to add the back item.
-     * @param goal The GUI to go back to.
+     * @param goal   The GUI to go back to.
      */
     public static void addBackItem(@NotNull PatternPane target,
-                                   @NotNull Gui goal){
+                                   @NotNull Gui goal) {
         target.bindItem('B', backItem(goal));
     }
 
@@ -66,42 +70,47 @@ public class GuiGlobalItems {
     /**
      * Get a background item with backgroundMat as the displayed material.
      * A background item is a GuiItem that do nothing when interacted with and have an empty name.
+     *
      * @param backgroundMat The material to which the background item should be made of.
      * @return A background item with backgroundMat as material.
      */
-    public static GuiItem backgroundItem(Material backgroundMat){
+    public static GuiItem backgroundItem(Material backgroundMat) {
         ItemStack item = new ItemStack(backgroundMat);
         ItemMeta meta = item.getItemMeta();
         meta.setDisplayName("\u00A7c");
         item.setItemMeta(meta);
         return new GuiItem(item, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
     }
+
     /**
      * Get default background GuiItem.
      * A background item is a GuiItem that do nothing when interacted with and have an empty name.
+     *
      * @return A new instance of the default background item.
      */
-    public static GuiItem backgroundItem(){
+    public static GuiItem backgroundItem() {
         return backgroundItem(DEFAULT_BACKGROUND_MAT);
     }
 
     /**
      * Add default background item to a GUI pattern with the reserved character key <strong>0</strong>.
      * A background item is a GuiItem that do nothing when interacted with and have an empty name.
-     * @param target The pattern to add the background item.
+     *
+     * @param target        The pattern to add the background item.
      * @param backgroundMat The material of the background item.
      */
     public static void addBackgroundItem(@NotNull PatternPane target,
-                                         @NotNull Material backgroundMat){
+                                         @NotNull Material backgroundMat) {
         target.bindItem('0', backgroundItem(backgroundMat));
     }
 
     /**
      * Add default background item to a GUI pattern with the reserved character key <strong>0</strong>.
      * A background item is a GuiItem that do nothing when interacted with and have an empty name.
+     *
      * @param target The pattern to add the background item.
      */
-    public static void addBackgroundItem(@NotNull PatternPane target){
+    public static void addBackgroundItem(@NotNull PatternPane target) {
         addBackgroundItem(target, DEFAULT_BACKGROUND_MAT);
     }
 
@@ -112,13 +121,14 @@ public class GuiGlobalItems {
      * Create a new save setting GuiItem.
      * A save setting item is a GuiItem that save a changed setting when clicked.
      * This item also check if the player who interacted with the item have the permission to save before saving.
+     *
      * @param setting The setting to change.
-     * @param goal Parent GUI of this setting GUI. as setting will be change the display of goal GUI will be updated.
+     * @param goal    Parent GUI of this setting GUI. as setting will be change the display of goal GUI will be updated.
      * @return A save setting item.
      */
     public static GuiItem saveItem(
             @NotNull AbstractSettingGui setting,
-            @NotNull ValueUpdatableGui goal){
+            @NotNull ValueUpdatableGui goal) {
 
         ItemStack item = new ItemStack(DEFAULT_SAVE_ITEM);
         ItemMeta meta = item.getItemMeta();
@@ -131,34 +141,37 @@ public class GuiGlobalItems {
 
     // Create static non change item
     private static final GuiItem NO_CHANGE_ITEM;
+
     static {
         ItemStack item = new ItemStack(DEFAULT_NO_CHANGE_ITEM);
         ItemMeta meta = item.getItemMeta();
         meta.setDisplayName("\u00A77No change. can't save.");
         item.setItemMeta(meta);
-        NO_CHANGE_ITEM = new GuiItem(item,GuiGlobalActions.stayInPlace, CustomAnvil.instance);
+        NO_CHANGE_ITEM = new GuiItem(item, GuiGlobalActions.stayInPlace, CustomAnvil.instance);
     }
 
     /**
      * Get the global "no change" GuiItem.
      * The no change item do nothing when interacted, only the title is change to show there is no change.
+     *
      * @return The global "no change" item.
      */
-    public static GuiItem noChangeItem(){
+    public static GuiItem noChangeItem() {
         return NO_CHANGE_ITEM;
     }
 
     /**
      * Create a new "create and go to the setting GUI" GuiItem.
      * This item will create and open a setting GUI from the factory.
-     * @param item The item that will be displayed.
+     *
+     * @param item    The item that will be displayed.
      * @param factory The setting's GUI factory.
      * @return A formatted GuiItem that will create and open a GUI for the setting.
      */
     public static GuiItem openSettingGuiItem(
             @NotNull ItemStack item,
             @NotNull AbstractSettingGui.SettingGuiFactory factory
-    ){
+    ) {
         return new GuiItem(item, GuiGlobalActions.openSettingGuiAction(factory), CustomAnvil.instance);
     }
 
@@ -169,23 +182,24 @@ public class GuiGlobalItems {
      * Create a new Boolean setting GuiItem.
      * This item will create and open a boolean setting GUI from the factory.
      * The item will have its value written in the lore part of the item.
+     *
      * @param factory The setting's GUI factory.
-     * @param name Name of the item.
+     * @param name    Name of the item.
      * @return A formatted GuiItem that will create and open a GUI for the boolean setting.
      */
     public static GuiItem boolSettingGuiItem(
             @NotNull BoolSettingsGui.BoolSettingFactory factory,
             @NotNull String name
-    ){
+    ) {
         // Get item properties
         boolean value = factory.getConfiguredValue();
 
         Material itemMat;
         StringBuilder itemName = new StringBuilder("\u00A7");
-        if(value){
+        if (value) {
             itemMat = Material.GREEN_TERRACOTTA;
             itemName.append("a");
-        }else{
+        } else {
             itemMat = Material.RED_TERRACOTTA;
             itemName.append("c");
         }
@@ -199,12 +213,13 @@ public class GuiGlobalItems {
      * This item will create and open a boolean setting GUI from the factory.
      * The item will have its value written in the lore part of the item.
      * Item's name will be the factory set title.
+     *
      * @param factory The setting's GUI factory.
      * @return A formatted GuiItem that will create and open a GUI for the boolean setting.
      */
     public static GuiItem boolSettingGuiItem(
             @NotNull BoolSettingsGui.BoolSettingFactory factory
-    ){
+    ) {
         String configPath = getConfigNameFromPath(factory.getConfigPath());
         return boolSettingGuiItem(factory, CasedStringUtil.snakeToUpperSpacedCase(configPath));
     }
@@ -213,16 +228,17 @@ public class GuiGlobalItems {
      * Create a new int setting GuiItem.
      * This item will create and open an int setting GUI from the factory.
      * The item will have its value written in the lore part of the item.
+     *
      * @param factory The setting's GUI factory.
      * @param itemMat Displayed material of the item.
-     * @param name Name of the item.
+     * @param name    Name of the item.
      * @return A formatted GuiItem that will create and open a GUI for the int setting.
      */
     public static GuiItem intSettingGuiItem(
             @NotNull IntSettingsGui.IntSettingFactory factory,
             @NotNull Material itemMat,
             @NotNull String name
-    ){
+    ) {
         // Get item properties
         int value = factory.getConfiguredValue();
         StringBuilder itemName = new StringBuilder("\u00A7a").append(name);
@@ -235,6 +251,7 @@ public class GuiGlobalItems {
      * This item will create and open an int setting GUI from the factory.
      * The item will have its value written in the lore part of the item.
      * Item's name will be the factory set title.
+     *
      * @param factory The setting's GUI factory.
      * @param itemMat Displayed material of the item.
      * @return A formatted GuiItem that will create and open a GUI for the int setting.
@@ -242,18 +259,19 @@ public class GuiGlobalItems {
     public static GuiItem intSettingGuiItem(
             @NotNull IntSettingsGui.IntSettingFactory factory,
             @NotNull Material itemMat
-    ){
+    ) {
         String configPath = getConfigNameFromPath(factory.getConfigPath());
-        return intSettingGuiItem(factory, itemMat, CasedStringUtil.snakeToUpperSpacedCase(configPath));
+        return intSettingGuiItem(factory, itemMat, CasedStringUtil.detectToUpperSpacedCase(configPath));
     }
 
     /**
      * Create an arbitrary GuiItem from a unique setting and item's property.
-     * @param factory The setting's GUI factory.
+     *
-     * @param itemMat Displayed material of the item.
+     * @param factory  The setting's GUI factory.
+     * @param itemMat  Displayed material of the item.
      * @param itemName Name of the item.
-     * @param value Value of the setting when the item is created.
+     * @param value    Value of the setting when the item is created.
-     *              Will not update automatically, if the setting's value change, the item need to be created again.
+     *                 Will not update automatically, if the setting's value change, the item need to be created again.
      * @return A formatted GuiItem that will create and open a GUI for the setting.
      */
     private static GuiItem createGuiItemFromProperties(
@@ -261,13 +279,13 @@ public class GuiGlobalItems {
             @NotNull Material itemMat,
             @NotNull StringBuilder itemName,
             @NotNull Object value
-    ){
+    ) {
         // Create & initialise item
         ItemStack item = new ItemStack(itemMat);
         ItemMeta itemMeta = item.getItemMeta();
 
         itemMeta.setDisplayName(itemName.toString());
-        itemMeta.setLore(Collections.singletonList(SETTING_ITEM_LORE_PREFIX+value));
+        itemMeta.setLore(Collections.singletonList(SETTING_ITEM_LORE_PREFIX + value));
 
         item.setItemMeta(itemMeta);
         // Create GuiItem
@@ -277,14 +295,15 @@ public class GuiGlobalItems {
     /**
      * Get the setting name from the setting path.
      * For example: "gui.command.name" will return "name".
+     *
      * @param path The setting's path.
      * @return The setting's name.
      */
-    public static String getConfigNameFromPath(String path){
+    public static String getConfigNameFromPath(String path) {
         // Get index of first dot
         int indexOfDot = path.indexOf(".");
         // when indexOfDot == -1 (not fond), it is implied that indexOfDot+1 = 0. substring will keep the full path as expected
-        return path.substring(indexOfDot+1);
+        return path.substring(indexOfDot + 1);
     }
 
 }

src/main/java/xyz/alexcrea/cuanvil/gui/util/GuiSharedConstant.java

@@ -0,0 +1,53 @@
+package xyz.alexcrea.cuanvil.gui.util;
+
+import com.github.stefvanschie.inventoryframework.gui.GuiItem;
+import com.github.stefvanschie.inventoryframework.pane.Pane;
+import com.github.stefvanschie.inventoryframework.pane.PatternPane;
+import com.github.stefvanschie.inventoryframework.pane.util.Pattern;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import xyz.alexcrea.cuanvil.gui.config.global.MainConfigGui;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+public class GuiSharedConstant {
+
+    public static final List<Enchantment> SORTED_ENCHANTMENT_LIST;
+
+    static {
+        SORTED_ENCHANTMENT_LIST = Arrays.asList(Enchantment.values());
+        SORTED_ENCHANTMENT_LIST.sort(Comparator.comparing(ench -> ench.getKey().getKey()));
+    }
+
+    public static final Material SECONDARY_BACKGROUND_MATERIAL = Material.BLACK_STAINED_GLASS_PANE;
+    public static final GuiItem SECONDARY_BACKGROUND_ITEM = GuiGlobalItems.backgroundItem(GuiSharedConstant.SECONDARY_BACKGROUND_MATERIAL);
+
+    public static final String EMPTY_GUI_FULL_LINE = "000000000";
+
+    // Temporary values, until I get something better.
+    public static final boolean TEMPORARY_DO_SAVE_TO_DISK_EVERY_CHANGE = true;
+    public static final boolean TEMPORARY_DO_BACKUP_EVERY_SAVE = true;
+
+    public static final PatternPane BACK_TO_MAIN_MENU_BIG_LIST_DISPLAY_BACKGROUND_PANE;
+
+    static {
+        Pattern pattern = new Pattern(
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                GuiSharedConstant.EMPTY_GUI_FULL_LINE,
+                "B11111111"
+        );
+        BACK_TO_MAIN_MENU_BIG_LIST_DISPLAY_BACKGROUND_PANE = new PatternPane(0, 0, 9, 6, Pane.Priority.LOW, pattern);
+
+        GuiGlobalItems.addBackItem(BACK_TO_MAIN_MENU_BIG_LIST_DISPLAY_BACKGROUND_PANE, MainConfigGui.INSTANCE);
+
+        GuiGlobalItems.addBackgroundItem(BACK_TO_MAIN_MENU_BIG_LIST_DISPLAY_BACKGROUND_PANE);
+        BACK_TO_MAIN_MENU_BIG_LIST_DISPLAY_BACKGROUND_PANE.bindItem('1', GuiSharedConstant.SECONDARY_BACKGROUND_ITEM);
+
+    }
+
+}

src/main/java/xyz/alexcrea/cuanvil/util/CasedStringUtil.java

@@ -9,17 +9,18 @@ public class CasedStringUtil {
      * Transform a snake cased string to an upper-cased spaced string.
      * <p>
      * for example: if we use  "hello_world" as an input this function will return "Hello World".
+     *
      * @param snake_cased_string The input string.
-     * This argument NEED to be a snake cased string, or it will not work
+     *                           This argument NEED to be a snake cased string, or it will not work
      * @return The input as an upper-cased string with space separator.
      */
-    public static String snakeToUpperSpacedCase(String snake_cased_string){
+    public static String snakeToUpperSpacedCase(String snake_cased_string) {
-        if(snake_cased_string.contentEquals("")) return "";
+        if (snake_cased_string.contentEquals("")) return "";
         StringBuilder result = new StringBuilder();
 
         for (String word : snake_cased_string.split("_")) {
             result.append(" ");
-            if(word.isEmpty()) continue;
+            if (word.isEmpty()) continue;
             char firstChar = word.charAt(0);
 
             result.append(Character.toUpperCase(firstChar));
@@ -28,4 +29,30 @@ public class CasedStringUtil {
         return result.substring(1);
     }
 
+    public static String camelCaseToUpperSpaceCase(String camelCasedString) {
+        if (camelCasedString.isEmpty()) return camelCasedString;
+        StringBuilder stb = new StringBuilder();
+
+        char[] chars = camelCasedString.toCharArray();
+        stb.append(chars[0]);
+        for (int i = 1; i < chars.length; i++) {
+            char chr = chars[i];
+            if (Character.isUpperCase(chr)) {
+                stb.append(" ");
+            }
+            stb.append(chr);
+        }
+
+        return stb.toString();
+    }
+
+    public static String detectToUpperSpacedCase(String toDetect) {
+        //not advanced detection
+        if (toDetect.contains("_")) {
+            return snakeToUpperSpacedCase(toDetect);
+        } else {
+            return camelCaseToUpperSpaceCase(toDetect);
+        }
+    }
+
 }

src/main/kotlin/io/delilaheve/AnvilEventListener.kt

@@ -39,9 +39,10 @@ class AnvilEventListener : Listener {
         private const val ANVIL_INPUT_LEFT = 0
         private const val ANVIL_INPUT_RIGHT = 1
         private const val ANVIL_OUTPUT_SLOT = 2
+
         // static slot container
-        private val NO_SLOT = SlotContainer(SlotType.NO_SLOT,0)
+        private val NO_SLOT = SlotContainer(SlotType.NO_SLOT, 0)
-        private val CURSOR_SLOT = SlotContainer(SlotType.CURSOR,0)
+        private val CURSOR_SLOT = SlotContainer(SlotType.CURSOR, 0)
     }
 
     /**
@@ -55,22 +56,23 @@ class AnvilEventListener : Listener {
 
         // Should find player
         val player = event.view.player
-        if(!player.hasPermission(CustomAnvil.affectedByPluginPermission)) return
+        if (!player.hasPermission(CustomAnvil.affectedByPluginPermission)) return
 
         // Test rename lonely item
-        if(second == null){
+        if (second == null) {
             val resultItem = first.clone()
             var anvilCost = handleRename(resultItem, inventory)
 
             // Test/stop if nothing changed.
-            if(first == resultItem){
+            if (first == resultItem) {
+                CustomAnvil.log("no right item, But input is same as output")
                 event.result = null
                 return
             }
             // We don't manually set item here as vanilla do it (renaming)
             //event.result = null
 
-            anvilCost+= calculatePenalty(first,null,resultItem)
+            anvilCost += calculatePenalty(first, null, resultItem)
 
             handleAnvilXp(inventory, event, anvilCost)
             return
@@ -90,18 +92,19 @@ class AnvilEventListener : Listener {
             if (!first.isEnchantedBook() && !second.isEnchantedBook()) {
                 // we only need to be concerned with repair when neither item is a book
                 val repaired = resultItem.repairFrom(first, second)
-                anvilCost += if(repaired) ConfigOptions.itemRepairCost else 0
+                anvilCost += if (repaired) ConfigOptions.itemRepairCost else 0
             }
 
             // Test/stop if nothing changed.
-            if(first == resultItem){
+            if (first == resultItem) {
+                CustomAnvil.log("Mergable with second, But input is same as output")
                 event.result = null
                 return
             }
             // As calculatePenalty edit result, we need to calculate penalty after checking equality
-            anvilCost+= calculatePenalty(first, second, resultItem)
+            anvilCost += calculatePenalty(first, second, resultItem)
             // Calculate rename cost
-            anvilCost+= handleRename(resultItem, inventory)
+            anvilCost += handleRename(resultItem, inventory)
 
             // Finally, we set result
             event.result = resultItem
@@ -112,34 +115,36 @@ class AnvilEventListener : Listener {
 
         // Test for unit repair
         val unitRepairAmount = first.getRepair(second)
-        if(unitRepairAmount != null){
+        if (unitRepairAmount != null) {
             val resultItem = first.clone()
             var anvilCost = handleRename(resultItem, inventory)
 
             val repairAmount = resultItem.unitRepair(second.amount, unitRepairAmount)
-            if(repairAmount > 0){
+            if (repairAmount > 0) {
-                anvilCost += repairAmount*ConfigOptions.unitRepairCost
+                anvilCost += repairAmount * ConfigOptions.unitRepairCost
             }
             // We do not care about right item penalty for unit repair
-            anvilCost+= calculatePenalty(first,null,resultItem)
+            anvilCost += calculatePenalty(first, null, resultItem)
 
             // Test/stop if nothing changed.
-            if(first == resultItem){
+            if (first == resultItem) {
+                CustomAnvil.log("unit repair, But input is same as output")
                 event.result = null
                 return
             }
             event.result = resultItem
 
             handleAnvilXp(inventory, event, anvilCost)
-        }else{
+        } else {
+            CustomAnvil.log("no anvil fuse type found")
             event.result = null
         }
     }
 
-    private fun handleRename(resultItem: ItemStack, inventory: AnvilInventory): Int{
+    private fun handleRename(resultItem: ItemStack, inventory: AnvilInventory): Int {
         // Rename item and add renaming cost
         resultItem.itemMeta?.let {
-            if(!it.displayName.contentEquals(inventory.renameText)){
+            if (!it.displayName.contentEquals(inventory.renameText)) {
                 it.setDisplayName(inventory.renameText)
                 resultItem.itemMeta = it
                 return ConfigOptions.itemRenameCost
@@ -154,9 +159,11 @@ class AnvilEventListener : Listener {
     @EventHandler(ignoreCancelled = true)
     fun anvilExtractionCheck(event: InventoryClickEvent) {
         val player = event.whoClicked as? Player ?: return
-        if(!player.hasPermission(CustomAnvil.affectedByPluginPermission)) return
+        if (!player.hasPermission(CustomAnvil.affectedByPluginPermission)) return
         val inventory = event.inventory as? AnvilInventory ?: return
-        if (event.rawSlot != ANVIL_OUTPUT_SLOT) { return }
+        if (event.rawSlot != ANVIL_OUTPUT_SLOT) {
+            return
+        }
         val output = inventory.getItem(ANVIL_OUTPUT_SLOT) ?: return
         val leftItem = inventory.getItem(ANVIL_INPUT_LEFT) ?: return
         val rightItem = inventory.getItem(ANVIL_INPUT_RIGHT)
@@ -168,110 +175,117 @@ class AnvilEventListener : Listener {
                 || (unitRepairResult != null)
 
         // True if there was no change or not allowed
-        if((output == inventory.getItem(ANVIL_INPUT_LEFT))
+        if ((output == inventory.getItem(ANVIL_INPUT_LEFT))
-            || !allowed){
+            || !allowed
+        ) {
 
             event.result = Event.Result.DENY
             return
         }
-        if(rightItem == null){
+        if (rightItem == null) {
             event.result = Event.Result.ALLOW
             return
         }
-        if(canMerge){
+        if (canMerge) {
             event.result = Event.Result.ALLOW
-        }else if(unitRepairResult != null){
+        } else if (unitRepairResult != null) {
-            onUnitRepairExtract(leftItem, rightItem, output,
+            onUnitRepairExtract(
-                unitRepairResult, event, player, inventory)
+                leftItem, rightItem, output,
+                unitRepairResult, event, player, inventory
+            )
 
             return
         }
     }
 
-    private fun onUnitRepairExtract(leftItem: ItemStack,
+    private fun onUnitRepairExtract(
-                                    rightItem: ItemStack,
+        leftItem: ItemStack,
-                                    output: ItemStack,
+        rightItem: ItemStack,
-                                    unitRepairResult: Double,
+        output: ItemStack,
-                                    event: InventoryClickEvent,
+        unitRepairResult: Double,
-                                    player: Player,
+        event: InventoryClickEvent,
-                                    inventory: AnvilInventory){
+        player: Player,
+        inventory: AnvilInventory
+    ) {
         val resultCopy = leftItem.clone()
         val resultAmount = resultCopy.unitRepair(
-            rightItem.amount, unitRepairResult)
+            rightItem.amount, unitRepairResult
+        )
 
         // To avoid vanilla, we cancel the event for unit repair
         event.result = Event.Result.DENY
         event.isCancelled = true
         // And we give the item manually
         // But first we check if we should give the item
-        val slotDestination = getActionSlot(event,player)
+        val slotDestination = getActionSlot(event, player)
-        if(slotDestination.type == SlotType.NO_SLOT) return
+        if (slotDestination.type == SlotType.NO_SLOT) return
 
         // Test repair cost
         var repairCost = 0
-        if(player.gameMode != GameMode.CREATIVE){
+        if (player.gameMode != GameMode.CREATIVE) {
             // Get repairCost
             leftItem.itemMeta?.let { leftMeta ->
                 val leftName = leftMeta.displayName
                 output.itemMeta?.let {
-                    if(!leftName.contentEquals(it.displayName)){
+                    if (!leftName.contentEquals(it.displayName)) {
-                        repairCost+= ConfigOptions.itemRenameCost
+                        repairCost += ConfigOptions.itemRenameCost
                     }
                 }
             }
 
-            repairCost+= calculatePenalty(leftItem,null,resultCopy)
+            repairCost += calculatePenalty(leftItem, null, resultCopy)
-            repairCost+= resultAmount*ConfigOptions.unitRepairCost
+            repairCost += resultAmount * ConfigOptions.unitRepairCost
 
-            if((inventory.maximumRepairCost < repairCost)
+            if ((inventory.maximumRepairCost < repairCost)
-                        || (player.level < repairCost)) return
+                || (player.level < repairCost)
+            ) return
         }
         // If not creative middle click...
-        if(event.click != ClickType.MIDDLE){
+        if (event.click != ClickType.MIDDLE) {
             // We remove what should be removed
-            inventory.setItem(ANVIL_INPUT_LEFT,null)
+            inventory.setItem(ANVIL_INPUT_LEFT, null)
-            rightItem.amount-= resultAmount
+            rightItem.amount -= resultAmount
-            inventory.setItem(ANVIL_INPUT_RIGHT,rightItem)
+            inventory.setItem(ANVIL_INPUT_RIGHT, rightItem)
             inventory.setItem(ANVIL_OUTPUT_SLOT, null)
-            player.level-= repairCost
+            player.level -= repairCost
         }
 
         // Finally, we add the item to the player
-        if(slotDestination.type == SlotType.CURSOR){
+        if (slotDestination.type == SlotType.CURSOR) {
             player.setItemOnCursor(output)
-        }else{// We assume SlotType == SlotType.INVENTORY
+        } else {// We assume SlotType == SlotType.INVENTORY
-            player.inventory.setItem(slotDestination.slot,output)
+            player.inventory.setItem(slotDestination.slot, output)
         }
     }
 
     /**
      * Get the destination slot or "NO_SLOT" slot container if there is no slot available
      */
-    private fun getActionSlot(event: InventoryClickEvent, player: Player): SlotContainer{
+    private fun getActionSlot(event: InventoryClickEvent, player: Player): SlotContainer {
-        if(event.isShiftClick){
+        if (event.isShiftClick) {
             val inventory = player.inventory
-            val firstEmpty =  inventory.firstEmpty()
+            val firstEmpty = inventory.firstEmpty()
-            if(firstEmpty == -1){
+            if (firstEmpty == -1) {
                 return NO_SLOT
             }
             //check hotbare full
             var slotIndex = 8
-            while(slotIndex >= 0 && ((inventory.getItem(slotIndex)?.type ?: Material.AIR) != Material.AIR)){
+            while (slotIndex >= 0 && ((inventory.getItem(slotIndex)?.type ?: Material.AIR) != Material.AIR)) {
                 slotIndex--
             }
-            if(slotIndex >= 0){
+            if (slotIndex >= 0) {
-                return SlotContainer(SlotType.INVENTORY,slotIndex)
+                return SlotContainer(SlotType.INVENTORY, slotIndex)
             }
             slotIndex = 35 //4*9 - 1 (max of player inventory)
-            while(slotIndex >= 9 && ((inventory.getItem(slotIndex)?.type ?: Material.AIR) != Material.AIR)){
+            while (slotIndex >= 9 && ((inventory.getItem(slotIndex)?.type ?: Material.AIR) != Material.AIR)) {
                 slotIndex--
             }
-            if(slotIndex < 9){
+            if (slotIndex < 9) {
                 return NO_SLOT
             }
-            return SlotContainer(SlotType.INVENTORY,slotIndex)
+            return SlotContainer(SlotType.INVENTORY, slotIndex)
-        }else{
+        } else {
-            if(player.itemOnCursor.type != Material.AIR){
+            if (player.itemOnCursor.type != Material.AIR) {
                 return NO_SLOT
             }
             return CURSOR_SLOT
@@ -282,24 +296,29 @@ class AnvilEventListener : Listener {
      * Function to calculate work penalty of anvil work
      * Also change result work penalty
      */
-    private fun calculatePenalty(left: ItemStack, right: ItemStack?, result: ItemStack): Int{
+    private fun calculatePenalty(left: ItemStack, right: ItemStack?, result: ItemStack): Int {
         // Extracted From https://minecraft.fandom.com/wiki/Anvil_mechanics#Enchantment_equation
         // Calculate work penalty
         val leftPenalty = (left.itemMeta as? Repairable)?.repairCost ?: 0
         val rightPenalty =
-            if(right == null){ 0 }
+            if (right == null) {
-            else{ (right.itemMeta as? Repairable)?.repairCost ?: 0 }
+                0
+            } else {
+                (right.itemMeta as? Repairable)?.repairCost ?: 0
+            }
 
         // Try to set work penalty for the result item
         result.itemMeta?.let {
-            (it as? Repairable)?.repairCost = leftPenalty*2+1
+            (it as? Repairable)?.repairCost = leftPenalty * 2 + 1
             result.itemMeta = it
         }
 
-        CustomAnvil.log("Calculated penalty: " +
+        CustomAnvil.log(
-                "leftPenalty: $leftPenalty, " +
+            "Calculated penalty: " +
-                "rightPenalty: $rightPenalty, " +
+                    "leftPenalty: $leftPenalty, " +
-                "result penalty: ${(result.itemMeta as? Repairable)?.repairCost ?: "none"}")
+                    "rightPenalty: $rightPenalty, " +
+                    "result penalty: ${(result.itemMeta as? Repairable)?.repairCost ?: "none"}"
+        )
 
         return leftPenalty + rightPenalty
     }
@@ -308,7 +327,7 @@ class AnvilEventListener : Listener {
      * Function to calculate right enchantment values
      * it include enchantment placed on final item and conflicting enchantment
      */
-    private fun getRightValues(right: ItemStack, result:ItemStack) : Int {
+    private fun getRightValues(right: ItemStack, result: ItemStack): Int {
         // Calculate right value and illegal enchant penalty
         var illegalPenalty = 0
         var rightValue = 0
@@ -319,12 +338,16 @@ class AnvilEventListener : Listener {
 
         for (enchantment in right.findEnchantments()) {
             // count enchant as illegal enchant if it conflicts with another enchant or not in result
-            if((enchantment.key !in resultEnchsKeys)){
+            if ((enchantment.key !in resultEnchsKeys)) {
                 resultEnchsKeys.add(enchantment.key)
-                val conflictType = ConfigHolder.CONFLICT_HOLDER.conflictManager.isConflicting(resultEnchsKeys,result.type,enchantment.key)
+                val conflictType = ConfigHolder.CONFLICT_HOLDER.conflictManager.isConflicting(
+                    resultEnchsKeys,
+                    result.type,
+                    enchantment.key
+                )
                 resultEnchsKeys.remove(enchantment.key)
 
-                if(ConflictType.BIG_CONFLICT == conflictType){
+                if (ConflictType.BIG_CONFLICT == conflictType) {
                     illegalPenalty += ConfigOptions.sacrificeIllegalCost
                 }
                 continue
@@ -338,9 +361,11 @@ class AnvilEventListener : Listener {
             rightValue += value
 
         }
-        CustomAnvil.log("Calculated right values: " +
+        CustomAnvil.log(
-                "rightValue: $rightValue, " +
+            "Calculated right values: " +
-                "illegalPenalty: $illegalPenalty")
+                    "rightValue: $rightValue, " +
+                    "illegalPenalty: $illegalPenalty"
+        )
 
         return rightValue + illegalPenalty
     }
@@ -348,15 +373,16 @@ class AnvilEventListener : Listener {
     /**
      * Display xp needed for the work on the anvil inventory
      */
-    private fun handleAnvilXp(inventory: AnvilInventory,
+    private fun handleAnvilXp(
-                              event: PrepareAnvilEvent,
+        inventory: AnvilInventory,
-                              anvilCost: Int){
+        event: PrepareAnvilEvent,
+        anvilCost: Int
+    ) {
         // Test repair cost limit
-        val finalAnvilCost: Int
+        val finalAnvilCost = if (ConfigOptions.limitRepairCost) {
-        if (ConfigOptions.limitRepairCost) {
+            min(anvilCost, ConfigOptions.limitRepairValue)
-            finalAnvilCost = min(anvilCost, ConfigOptions.limitRepairValue)
+        } else {
-        }else{
+            anvilCost
-            finalAnvilCost = anvilCost
         }
 
         /* Because Minecraft likes to have the final say in the repair cost displayed
@@ -379,7 +405,7 @@ class AnvilEventListener : Listener {
 
 
 private class SlotContainer(val type: SlotType, val slot: Int)
-private enum class SlotType{
+private enum class SlotType {
     CURSOR,
     INVENTORY,
     NO_SLOT

src/main/kotlin/io/delilaheve/CustomAnvil.kt

@@ -7,14 +7,14 @@ import org.bukkit.plugin.java.JavaPlugin
 import xyz.alexcrea.cuanvil.command.EditConfigExecutor
 import xyz.alexcrea.cuanvil.command.ReloadExecutor
 import xyz.alexcrea.cuanvil.config.ConfigHolder
+import xyz.alexcrea.cuanvil.listener.ChatEventListener
 import xyz.alexcrea.cuanvil.util.Metrics
 import xyz.alexcrea.cuanvil.util.MetricsUtil
 import java.io.File
 import java.io.FileReader
 
 /**
- * Bukkit/Spigot/Paper plugin to alter enchantment max
+ * Bukkit/Spigot/Paper plugin to alter anvil feature
- * levels and allow unsafe enchantment combinations
  */
 class CustomAnvil : JavaPlugin() {
 
@@ -24,23 +24,31 @@ class CustomAnvil : JavaPlugin() {
 
         // Permission string required to use the plugin's features
         const val affectedByPluginPermission = "ca.affected"
+
         // Permission string required to bypass enchantment conflicts test
         const val bypassFusePermission = "ca.bypass.fuse"
+
         // Permission string required to bypass enchantment conflicts test
         const val bypassLevelPermission = "ca.bypass.level"
+
         // Permission string required to reload the config
         const val commandReloadPermission = "ca.command.reload"
+
         // Permission string required to edit the plugin's config
         const val editConfigPermission = "ca.config.edit"
 
         // Command Name to reload the config
         const val commandReloadName = "anvilconfigreload"
+
         // Test command name
         const val commandTestName = "customanvilconfig"
 
         // Current plugin instance
         lateinit var instance: CustomAnvil
 
+        // Chat message listener
+        lateinit var chatListener: ChatEventListener
+
         /**
          * Logging handler
          */
@@ -49,6 +57,15 @@ class CustomAnvil : JavaPlugin() {
                 instance.logger.info(message)
             }
         }
+
+        /**
+         * Vebose Logging handler
+         */
+        fun verboseLog(message: String) {
+            if (ConfigOptions.verboseDebugLog) {
+                instance.logger.info(message)
+            }
+        }
     }
 
     /**
@@ -59,16 +76,19 @@ class CustomAnvil : JavaPlugin() {
 
         // Disable old plugin name if exist
         val potentialPlugin = Bukkit.getPluginManager().getPlugin("UnsafeEnchantsPlus")
-        if(potentialPlugin != null){
+        if (potentialPlugin != null) {
             Bukkit.getPluginManager().disablePlugin(potentialPlugin)
             logger.warning("An old version of this plugin was detected")
             logger.warning("Please note CustomAnvil is a more recent version of UnsafeEnchantsPlus")
         }
 
-        // Load config
+        // Load chat listener
+        chatListener = ChatEventListener()
+        Bukkit.getPluginManager().registerEvents(chatListener, this)
 
+        // Load config
         val success = ConfigHolder.loadConfig()
-        if(!success) return
+        if (!success) return
 
         // Load metrics
         val metric = Metrics(this, bstatsPluginId)
@@ -83,26 +103,28 @@ class CustomAnvil : JavaPlugin() {
         )
     }
 
-    fun reloadResource(resourceName: String,
+    fun reloadResource(
-                       hardFailSafe:Boolean = true): YamlConfiguration?{
+        resourceName: String,
+        hardFailSafe: Boolean = true
+    ): YamlConfiguration? {
         // Save default resource
-        val file = File(dataFolder,resourceName)
+        val file = File(dataFolder, resourceName)
-        if(!file.exists()){
+        if (!file.exists()) {
-            saveResource(resourceName,false)
+            saveResource(resourceName, false)
         }
         // Load resource
         val yamlConfig = YamlConfiguration()
         try {
             val configReader = FileReader(file)
             yamlConfig.load(configReader)
-        } catch (test: Exception){
+        } catch (test: Exception) {
-            if(hardFailSafe){
+            if (hardFailSafe) {
                 // This is important and may impact gameplay if it does not load.
                 // Failsafe is to stop the plugin
                 logger.severe("Resource $resourceName Could not be load or reload.")
                 logger.severe("Disabling plugin.")
                 Bukkit.getPluginManager().disablePlugin(this)
-            }else{
+            } else {
                 logger.warning("Resource $resourceName Could not be load or reload.")
             }
             return null

src/main/kotlin/io/delilaheve/util/ConfigOptions.kt

@@ -12,66 +12,97 @@ object ConfigOptions {
 
     // Path for default enchantment limits
     private const val DEFAULT_LIMIT_PATH = "default_limit"
+
     // Path for limiting repair cost
     const val LIMIT_REPAIR_COST = "limit_repair_cost"
+
     // Path for repair value limit
     const val LIMIT_REPAIR_VALUE = "limit_repair_value"
+
     // Path for level cost on item repair
     const val ITEM_REPAIR_COST = "item_repair_cost"
+
     // Path for level cost on unit repair
     const val UNIT_REPAIR_COST = "unit_repair_cost"
+
     // Path for level cost on item renaming
     const val ITEM_RENAME_COST = "item_rename_cost"
+
     // Path for level cost on illegal enchantment on sacrifice
     const val SACRIFICE_ILLEGAL_COST = "sacrifice_illegal_enchant_cost"
+
     // Path for removing repair cost limits
     const val REMOVE_REPAIR_LIMIT = "remove_repair_limit"
+
     // Root path for enchantment limits
     const val ENCHANT_LIMIT_ROOT = "enchant_limits"
+
     // Root path for enchantment values
     const val ENCHANT_VALUES_ROOT = "enchant_values"
+
     // Keys for specific enchantment values
     private const val KEY_BOOK = "book"
     private const val KEY_ITEM = "item"
+
     // Debug logging toggle path
     private const val DEBUG_LOGGING = "debug_log"
 
+    // Debug verbose logging toggle path
+    private const val VERBOSE_DEBUG_LOGGING = "debug_log_verbose"
+
     // Default value for enchantment limits
     private const val DEFAULT_ENCHANT_LIMIT = 5
+
     // Default value for limiting repair cost
     const val DEFAULT_LIMIT_REPAIR = false
+
     // Default value for repair cost limit
     const val DEFAULT_LIMIT_REPAIR_VALUE = 39
+
     // Default value for level cost on item repair
     const val DEFAULT_ITEM_REPAIR_COST = 2
+
     // Default value for level cost per unit repair
     const val DEFAULT_UNIT_REPAIR_COST = 1
+
     // Default value for level cost on item renaming
     const val DEFAULT_ITEM_RENAME_COST = 1
+
     // Default value for level cost on illegal enchantment on sacrifice
     const val DEFAULT_SACRIFICE_ILLEGAL_COST = 1
+
     // Valid range for repair cost limit
     @JvmField
     val REPAIR_LIMIT_RANGE = 1..39
+
     // Valid range for repair cost
     @JvmField
     val REPAIR_COST_RANGE = 0..255
+
     // Valid range for rename cost
     @JvmField
     val ITEM_RENAME_COST_RANGE = 0..255
+
     // Valid range for illegal enchantment conflict cost
     @JvmField
     val SACRIFICE_ILLEGAL_COST_RANGE = 0..255
+
     // Default for removing repair cost limits
     const val DEFAULT_REMOVE_LIMIT = false
+
     // Valid range for an enchantment limit
     @JvmField
     val ENCHANT_LIMIT_RANGE = 1..255
+
     // Default value for an enchantment multiplier
     private const val DEFAULT_ENCHANT_VALUE = 0
+
     // Default value for debug logging
     private const val DEFAULT_DEBUG_LOG = false
 
+    // Default value for debug logging
+    private const val DEFAULT_VERBOSE_DEBUG_LOG = false
+
     /**
      * Default enchantment limit
      */
@@ -151,6 +182,7 @@ object ConfigOptions {
                 .takeIf { it in SACRIFICE_ILLEGAL_COST_RANGE }
                 ?: DEFAULT_SACRIFICE_ILLEGAL_COST
         }
+
     /**
      * Whether to remove repair cost limit
      */
@@ -171,6 +203,16 @@ object ConfigOptions {
                 .getBoolean(DEBUG_LOGGING, DEFAULT_DEBUG_LOG)
         }
 
+    /**
+     * Whether to show verbose debug logging
+     */
+    val verboseDebugLog: Boolean
+        get() {
+            return ConfigHolder.DEFAULT_CONFIG
+                .config
+                .getBoolean(VERBOSE_DEBUG_LOGGING, DEFAULT_VERBOSE_DEBUG_LOG)
+        }
+
     /**
      * Get the given [enchantment]'s limit
      */
@@ -203,8 +245,9 @@ object ConfigOptions {
     /**
      * Get an array of key of basic config options
      */
-    fun getBasicConfigKeys(): Array<String>{
+    fun getBasicConfigKeys(): Array<String> {
-        return arrayOf(DEFAULT_LIMIT_PATH,
+        return arrayOf(
+            DEFAULT_LIMIT_PATH,
             LIMIT_REPAIR_COST,
             LIMIT_REPAIR_VALUE,
             ITEM_REPAIR_COST,

src/main/kotlin/io/delilaheve/util/EnchantmentUtil.kt

@@ -32,40 +32,53 @@ object EnchantmentUtil {
         other.forEach { (enchantment, level) ->
             // Enchantment not yet in result list
             if (!containsKey(enchantment)) {
-                // Add the enchantment if it doesn't have conflicts, or, if player is allowed to bypass enchantment restrictions
+                // Add the enchantment if it doesn't have conflicts, or if player is allowed to bypass enchantment restrictions
                 this[enchantment] = level
-                if(!player.hasPermission(CustomAnvil.bypassFusePermission) &&
+                val conflictType =
-                    (ConfigHolder.CONFLICT_HOLDER.conflictManager.isConflicting(this.keys,mat,enchantment) != ConflictType.NO_CONFLICT)){
+                    ConfigHolder.CONFLICT_HOLDER.conflictManager.isConflicting(this.keys, mat, enchantment)
+                if (!player.hasPermission(CustomAnvil.bypassFusePermission) &&
+                    (conflictType != ConflictType.NO_CONFLICT)
+                ) {
+                    CustomAnvil.verboseLog("Enchantment not yet in result list, but there is conflict (${enchantment.key}, conflict: $conflictType)")
                     this.remove(enchantment)
                 }
 
             }
             // Enchantment already in result list
-            else{
+            else {
                 // ... and they are conflicting
-                if((ConfigHolder.CONFLICT_HOLDER.conflictManager.isConflicting(this.keys,mat,enchantment) != ConflictType.NO_CONFLICT)
+                val conflictType =
-                    && !player.hasPermission(CustomAnvil.bypassFusePermission)){
+                    ConfigHolder.CONFLICT_HOLDER.conflictManager.isConflicting(this.keys, mat, enchantment)
+                if ((conflictType != ConflictType.NO_CONFLICT)
+                    && !player.hasPermission(CustomAnvil.bypassFusePermission)
+                ) {
+                    CustomAnvil.verboseLog("Enchantment already in result list, and they are conflicting (${enchantment.key}, conflict: $conflictType)")
                     return@forEach
                 }
 
                 // ... and they're not the same level
-                if(this[enchantment] != other[enchantment]){
+                if (this[enchantment] != other[enchantment]) {
                     val newLevel = max(this[enchantment] ?: 0, other[enchantment] ?: 0)
                     // apply the greater of the two if non-zero
-                    if (newLevel > 0) { this[enchantment] = newLevel }
+
+                    if (newLevel > 0) {
+                        this[enchantment] = newLevel
+                    }
                 }
                 // ... and they're the same level
                 else {
                     // try to increase the enchantment level by 1
-                    var newLevel = this[enchantment]!! +1
+                    var newLevel = this[enchantment]!! + 1
                     // Get max level or 255 if player can bypass
-                    val maxLevel = if(player.hasPermission(CustomAnvil.bypassLevelPermission)){
+                    val maxLevel = if (player.hasPermission(CustomAnvil.bypassLevelPermission)) {
                         255
-                    }else{
+                    } else {
                         ConfigOptions.enchantLimit(enchantment)
                     }
                     newLevel = min(newLevel, maxLevel)
-                    if (newLevel > 0) { this[enchantment] = newLevel }
+                    if (newLevel > 0) {
+                        this[enchantment] = newLevel
+                    }
                 }
             }
         }

src/main/kotlin/io/delilaheve/util/ItemUtil.kt

@@ -75,7 +75,7 @@ object ItemUtil {
         (itemMeta as? Damageable)?.let {
             val durability = type.maxDurability.toInt()
             val firstDamage = (first.itemMeta as? Damageable)?.damage ?: 0
-            if( firstDamage == 0) return false
+            if (firstDamage == 0) return false
 
             val firstDurability = durability - firstDamage
             val secondDamage = (second.itemMeta as? Damageable)?.damage ?: 0
@@ -96,12 +96,12 @@ object ItemUtil {
         (itemMeta as? Damageable)?.let {
             val durability = type.maxDurability.toInt()
             val firstDamage = it.damage
-            if( firstDamage == 0) return 0
+            if (firstDamage == 0) return 0
             var unitCount = 0
             var damage = firstDamage
-            while((unitCount < unitAmount) && (damage > 0)){
+            while ((unitCount < unitAmount) && (damage > 0)) {
                 unitCount++
-                damage = ceil(firstDamage - durability*percentPerUnit*unitCount).toInt()
+                damage = ceil(firstDamage - durability * percentPerUnit * unitCount).toInt()
             }
 
             it.damage = max(damage, 0)

src/main/kotlin/xyz/alexcrea/cuanvil/command/EditConfigExecutor.kt

@@ -5,17 +5,17 @@ import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.HumanEntity
-import xyz.alexcrea.cuanvil.gui.MainConfigGui
+import xyz.alexcrea.cuanvil.gui.config.global.MainConfigGui
 import xyz.alexcrea.cuanvil.gui.util.GuiGlobalActions
 
 class EditConfigExecutor : CommandExecutor {
 
     override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<out String>): Boolean {
-        if(!sender.hasPermission(CustomAnvil.editConfigPermission)) {
+        if (!sender.hasPermission(CustomAnvil.editConfigPermission)) {
             sender.sendMessage(GuiGlobalActions.NO_EDIT_PERM)
             return false
         }
-        if(sender !is HumanEntity) return false
+        if (sender !is HumanEntity) return false
         MainConfigGui.INSTANCE.show(sender)
 
         return true

src/main/kotlin/xyz/alexcrea/cuanvil/command/ReloadExecutor.kt

@@ -5,25 +5,26 @@ import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
 import org.bukkit.command.CommandSender
 import xyz.alexcrea.cuanvil.config.ConfigHolder
-import xyz.alexcrea.cuanvil.gui.config.BasicConfigGui
+import xyz.alexcrea.cuanvil.gui.config.global.BasicConfigGui
-import xyz.alexcrea.cuanvil.gui.config.EnchantCostConfigGui
+import xyz.alexcrea.cuanvil.gui.config.global.EnchantConflictGui
-import xyz.alexcrea.cuanvil.gui.config.EnchantLimitConfigGui
+import xyz.alexcrea.cuanvil.gui.config.global.EnchantCostConfigGui
+import xyz.alexcrea.cuanvil.gui.config.global.EnchantLimitConfigGui
 import xyz.alexcrea.cuanvil.util.MetricsUtil
 
 class ReloadExecutor : CommandExecutor {
     override fun onCommand(sender: CommandSender, cmd: Command, cmdstr: String, args: Array<out String>): Boolean {
-        if(!sender.hasPermission(CustomAnvil.commandReloadPermission)) {
+        if (!sender.hasPermission(CustomAnvil.commandReloadPermission)) {
             sender.sendMessage("§cYou do not have permission to reload the config")
             return false
         }
         sender.sendMessage("§eReloading config...")
-        val hardfail = args.isNotEmpty() && ("hard".equals(args[0],true))
+        val hardfail = args.isNotEmpty() && ("hard".equals(args[0], true))
         val commandSuccess = commandBody(hardfail)
-        if(commandSuccess){
+        if (commandSuccess) {
             sender.sendMessage("§aConfig reloaded !")
-        }else{
+        } else {
             sender.sendMessage("§cConfig was not able to be reloaded...")
-            if(hardfail){
+            if (hardfail) {
                 sender.sendMessage("§4Hard fail, plugin disabled")
             }
         }
@@ -33,20 +34,21 @@ class ReloadExecutor : CommandExecutor {
     /**
      * Execute the command, return true if success or false otherwise
      */
-    private fun commandBody(hardfail: Boolean): Boolean{
+    private fun commandBody(hardfail: Boolean): Boolean {
         try {
-            if(!ConfigHolder.reloadAllFromDisk(hardfail)) return false
+            if (!ConfigHolder.reloadAllFromDisk(hardfail)) return false
 
             // Then update all global gui containing value from config
             BasicConfigGui.INSTANCE.updateGuiValues()
             EnchantCostConfigGui.INSTANCE.updateGuiValues()
             EnchantLimitConfigGui.INSTANCE.updateGuiValues()
+            EnchantConflictGui.INSTANCE.reloadValues()
 
             // & update metric
             MetricsUtil.testIfConfigIsDefault()
 
             return true
-        }catch (e: Exception){
+        } catch (e: Exception) {
             e.printStackTrace()
             return false
         }

src/main/kotlin/xyz/alexcrea/cuanvil/group/AbstractMaterialGroup.kt

@@ -4,7 +4,7 @@ import org.bukkit.Material
 import java.util.*
 
 abstract class AbstractMaterialGroup(private val name: String) {
-    protected val includedMaterial by lazy {createDefaultSet()}
+    protected val includedMaterial by lazy { createDefaultSet() }
 
     /**
      * Get the group default set
@@ -14,37 +14,78 @@ abstract class AbstractMaterialGroup(private val name: String) {
     /**
      * Get if a material is allowed following the group policy
      */
-    fun contain(mat : Material): Boolean {
+    open fun contain(mat: Material): Boolean {
-        return mat in includedMaterial
+        return mat in getMaterials()
     }
 
     /**
      * Get if a group is referenced by this:
      */
-    abstract fun isReferencing(other : AbstractMaterialGroup): Boolean
+    abstract fun isReferencing(other: AbstractMaterialGroup): Boolean
 
     /**
      * Push a material to this group to follow this group policy
      */
-    abstract fun addToPolicy(mat : Material)
+    abstract fun addToPolicy(mat: Material)
 
     /**
      * Push a group to this group to follow this group policy
      */
-    abstract fun addToPolicy(other : AbstractMaterialGroup)
+    abstract fun addToPolicy(other: AbstractMaterialGroup)
+
+    /**
+     * Get the group contained material as a set
+     */
+    abstract fun getMaterials(): EnumSet<Material>
+
+    /**
+     * Get the group non-inherited material as a set
+     */
+    open fun getNonGroupInheritedMaterials(): EnumSet<Material> {
+        return includedMaterial
+    }
+
+    /**
+     * Get the group non-inherited material as a set
+     */
+    open fun setNonGroupInheritedMaterials(materials: EnumSet<Material>) {
+        this.includedMaterial.clear()
+        this.includedMaterial.addAll(materials)
+    }
 
     /**
      * Get the group name in case something is wrong
      */
-    fun getName(): String {
+    open fun getName(): String {
         return name
     }
 
     /**
-     * Get the group as a set
+     * Update the contained groups of this group
      */
-    fun getSet(): Set<Material> {
+    abstract fun setGroups(groups: MutableSet<AbstractMaterialGroup>)
-        return includedMaterial
+
+    /**
+     * Get the contained group of this material group
+     */
+    abstract fun getGroups(): MutableSet<AbstractMaterialGroup>
+
+    open fun getRepresentativeMaterial(): Material {
+        // Test inner material
+        val matIterator = includedMaterial.iterator()
+        while (matIterator.hasNext()) {
+            val material = matIterator.next()
+            if (material.isAir) continue
+            return material
+        }
+        // Test included group representative material
+        val groupIterator = getGroups().iterator()
+        while (groupIterator.hasNext()) {
+            val groupMat = groupIterator.next().getRepresentativeMaterial()
+            if (groupMat.isAir) continue
+            return groupMat
+        }
+        return Material.PAPER
     }
 
 }

src/main/kotlin/xyz/alexcrea/cuanvil/group/EnchantConflictGroup.kt

@@ -1,29 +1,36 @@
 package xyz.alexcrea.cuanvil.group
 
+import io.delilaheve.CustomAnvil
 import org.bukkit.Material
 import org.bukkit.enchantments.Enchantment
 
-class EnchantConflictGroup(private val cantConflict: AbstractMaterialGroup, private val minBeforeBlock: Int){
+class EnchantConflictGroup(
+    val name: String,
+    private val cantConflict: AbstractMaterialGroup,
+    val minBeforeBlock: Int
+) {
 
     private val enchantments = HashSet<Enchantment>()
 
-    fun addEnchantment(ench: Enchantment){
+    fun addEnchantment(enchant: Enchantment) {
-        enchantments.add(ench)
+        enchantments.add(enchant)
     }
-    fun allowed(enchants: Set<Enchantment>, mat: Material) : Boolean{
+
-        if(enchantments.size < minBeforeBlock){
+    fun allowed(enchants: Set<Enchantment>, mat: Material): Boolean {
+        if (enchantments.size < minBeforeBlock) {
             return true
         }
 
-        if(cantConflict.contain(mat)){
+        if (cantConflict.contain(mat)) {
             return true
         }
 
         // Count the amount of enchantment that are in the list
         var enchantAmount = 0
         for (enchantment in enchants) {
-            if(enchantment !in enchantments) continue
+            if (enchantment !in enchantments) continue
-            if(++enchantAmount > minBeforeBlock){
+            CustomAnvil.verboseLog("Enchant ${enchantment.key} is in: ${enchantAmount + 1}/$minBeforeBlock ")
+            if (++enchantAmount > minBeforeBlock) {
                 return false
             }
 
@@ -31,8 +38,28 @@ class EnchantConflictGroup(private val cantConflict: AbstractMaterialGroup, priv
         return true
     }
 
+    fun getCantConflictGroup(): AbstractMaterialGroup {
+        return this.cantConflict
+    }
+
     fun getEnchants(): HashSet<Enchantment> {
         return enchantments
     }
 
+    fun setEnchants(enchants: Set<Enchantment>) {
+        enchantments.clear()
+        enchantments.addAll(enchants)
+    }
+
+    fun getRepresentativeMaterial(): Material {
+        val groups = getCantConflictGroup().getGroups()
+        val groupIterator = groups.iterator()
+        while (groupIterator.hasNext()) {
+            val mat = groupIterator.next().getRepresentativeMaterial()
+            if (mat != Material.ENCHANTED_BOOK) return mat
+
+        }
+        return Material.ENCHANTED_BOOK
+    }
+
 }

src/main/kotlin/xyz/alexcrea/cuanvil/group/EnchantConflictManager.kt

@@ -10,125 +10,143 @@ class EnchantConflictManager {
 
     companion object {
         // Path for the enchantments list
-        private const val ENCH_LIST_PATH = "enchantments"
+        const val ENCH_LIST_PATH = "enchantments"
+
         // Path for group list related to the conflict
-        private const val CONFLICT_GROUP_PATH = "notAffectedGroups"
+        const val CONFLICT_GROUP_PATH = "notAffectedGroups"
+
         // Path for the maximum number of enchantment before validating the conflict
-        private const val ENCH_MAX_PATH = "maxEnchantmentBeforeConflict"
+        const val ENCH_MAX_PATH = "maxEnchantmentBeforeConflict"
+
         // Path for a flag: if the enchantment will be used in the last supported version
         // TODO maybe replace this system by a list of "future" enchantment.
         private const val FUTURE_USE_PATH = "useInFuture"
-        // Default name for an empty Material group
+
-        private val DEFAULT_EMPTY_GROUP = IncludeGroup("empty")
         // Default name for a joining group
         private const val DEFAULT_GROUP_NAME = "joinedGroup"
     }
 
     private lateinit var conflictMap: HashMap<Enchantment, ArrayList<EnchantConflictGroup>>
+    lateinit var conflictList: ArrayList<EnchantConflictGroup>
 
     // Read and prepare all conflict
-    fun prepareConflicts(config: ConfigurationSection, itemManager: ItemGroupManager){
+    fun prepareConflicts(config: ConfigurationSection, itemManager: ItemGroupManager) {
         conflictMap = HashMap()
+        conflictList = ArrayList()
 
         val keys = config.getKeys(false)
         for (key in keys) {
             val section = config.getConfigurationSection(key)!!
-            val conflict = createConflict(section,itemManager,key)
+            val conflict = createConflict(section, itemManager, key)
-            if(conflict != null){
-                addToMap(conflict)
-            }
 
+            addToMap(conflict)
+            conflictList.add(conflict)
         }
 
     }
 
     // Add the conflict to the map
-    private fun addToMap(conflict: EnchantConflictGroup){
+    private fun addToMap(conflict: EnchantConflictGroup) {
-        conflict.getEnchants().forEach{ enchant ->
+        conflict.getEnchants().forEach { enchant ->
-            if(!conflictMap.containsKey(enchant)){
+            addConflictToConflictMap(enchant, conflict)
-                conflictMap[enchant] = ArrayList()
-            }
-            conflictMap[enchant]!!.add(conflict)
         }
     }
 
+    fun addConflictToConflictMap(enchant: Enchantment, conflict: EnchantConflictGroup) {
+        if (!conflictMap.containsKey(enchant)) {
+            conflictMap[enchant] = ArrayList()
+        }
+        conflictMap[enchant]!!.add(conflict)
+    }
+
+    fun removeConflictFromMap(enchant: Enchantment, conflict: EnchantConflictGroup): Boolean {
+        return conflictMap[enchant]!!.remove(conflict)
+    }
+
     // create and read a conflict from a yaml section
-    private fun createConflict(section: ConfigurationSection,
+    private fun createConflict(
-                               itemManager: ItemGroupManager,
+        section: ConfigurationSection,
-                               conflictName: String): EnchantConflictGroup? {
+        itemManager: ItemGroupManager,
+        conflictName: String
+    ): EnchantConflictGroup {
         // Is it planed for the future
-        val futureUse = section.getBoolean(FUTURE_USE_PATH,false)
+        val futureUse = section.getBoolean(FUTURE_USE_PATH, false)
         // Create conflict
-        val conflict = createConflictObject(section,itemManager,conflictName)
+        val conflict = createConflictObject(section, itemManager, conflictName)
         // Read and add enchantment to conflict
         val enchantList = section.getStringList(ENCH_LIST_PATH)
         for (enchantName in enchantList) {
             val enchantKey = NamespacedKey.minecraft(enchantName)
             val enchant = Enchantment.getByKey(enchantKey)
-            if(enchant == null){
+            if (enchant == null) {
-                if(!futureUse){
+                if (!futureUse) {
                     CustomAnvil.instance.logger.warning("Enchantment $enchantName do not exist but was asked for conflict $conflictName")
                 }
                 continue
             }
             conflict.addEnchantment(enchant)
         }
-        if(conflict.getEnchants().size == 0){
+        if (conflict.getEnchants().size == 0) {
-            if(!futureUse){
+            if (!futureUse) {
-                CustomAnvil.instance.logger.warning("Conflict $conflictName do not have valid enchantment, it will not work")
+                CustomAnvil.instance.logger.warning("Conflict $conflictName do not have valid enchantment, it will not do anything")
             }
-            return null
         }
 
         return conflict
     }
 
-    private fun createConflictObject(section: ConfigurationSection,
+    private fun createConflictObject(
-                                     itemManager: ItemGroupManager,
+        section: ConfigurationSection,
-                                     conflictName: String): EnchantConflictGroup {
+        itemManager: ItemGroupManager,
+        conflictName: String
+    ): EnchantConflictGroup {
         // Get the maximum number of enchantment before validating the conflict
-        var minBeforeBlock = section.getInt(ENCH_MAX_PATH,0)
+        var minBeforeBlock = section.getInt(ENCH_MAX_PATH, 0)
-        if(minBeforeBlock < 0){
+        if (minBeforeBlock < 0) {
             minBeforeBlock = 0
             CustomAnvil.instance.logger.warning("Conflict $conflictName have an invalid value of $ENCH_MAX_PATH")
             CustomAnvil.instance.logger.warning("It should be more or equal to 0. default to 0")
         }
         // Find or create the selected group for the conflict
         val groupList = section.getStringList(CONFLICT_GROUP_PATH)
-        val finalGroup: AbstractMaterialGroup
+        val finalGroup = IncludeGroup(DEFAULT_GROUP_NAME)
-        if(groupList.size < 1){
+        for (groupName in groupList) {
-            finalGroup = DEFAULT_EMPTY_GROUP
+            finalGroup.addToPolicy(findGroup(groupName, itemManager, conflictName))
-        }else if(groupList.size == 1){
-            finalGroup = findGroup(groupList[0], itemManager, conflictName)
-        }else{
-            finalGroup = IncludeGroup(DEFAULT_GROUP_NAME)
-            for (groupName in groupList) {
-                finalGroup.addToPolicy(findGroup(groupName, itemManager, conflictName))
-            }
         }
+
         // Return conflict
-        return EnchantConflictGroup(finalGroup, minBeforeBlock)
+        return EnchantConflictGroup(conflictName, finalGroup, minBeforeBlock)
     }
 
-    private fun findGroup(groupName: String, itemManager: ItemGroupManager, conflictName: String): AbstractMaterialGroup {
+    private fun findGroup(
+        groupName: String,
+        itemManager: ItemGroupManager,
+        conflictName: String
+    ): AbstractMaterialGroup {
         val group = itemManager.get(groupName)
-        if(group == null){
+        if (group == null) {
             CustomAnvil.instance.logger.warning("Group $groupName do not exist but is ask by conflict $conflictName")
-            return DEFAULT_EMPTY_GROUP
+            return IncludeGroup("error_placeholder")
         }
 
         return group
     }
 
-    fun isConflicting(base: Set<Enchantment>,mat: Material, newEnchant: Enchantment): ConflictType {
+    fun isConflicting(base: Set<Enchantment>, mat: Material, newEnchant: Enchantment): ConflictType {
+        CustomAnvil.verboseLog("Testing conflict for ${newEnchant.key} on ${mat.key}")
         val conflictList = conflictMap[newEnchant] ?: return ConflictType.NO_CONFLICT
+        CustomAnvil.verboseLog("Did not get skipped")
 
         var result = ConflictType.NO_CONFLICT
         for (conflict in conflictList) {
-            if(!conflict.allowed(base,mat)) {
+            CustomAnvil.verboseLog("Is against ${conflict.name}")
-                if(conflict.getEnchants().size <= 1){
+            val conflicting = conflict.allowed(base, mat)
+            CustomAnvil.verboseLog("Was against ${conflict.name} and conflicting: $conflicting ")
+            if (!conflicting) {
+                if (conflict.getEnchants().size <= 1) {
                     result = ConflictType.SMALL_CONFLICT
-                }else{
+                    CustomAnvil.verboseLog("Small conflict, continuing")
+                } else {
                     return ConflictType.BIG_CONFLICT
                 }
             }
@@ -138,7 +156,7 @@ class EnchantConflictManager {
 
 }
 
-enum class ConflictType{
+enum class ConflictType {
     NO_CONFLICT,
     SMALL_CONFLICT,
     BIG_CONFLICT

src/main/kotlin/xyz/alexcrea/cuanvil/group/ExcludeGroup.kt

@@ -3,16 +3,17 @@ package xyz.alexcrea.cuanvil.group
 import org.bukkit.Material
 import java.util.*
 
-class ExcludeGroup(name: String): AbstractMaterialGroup(name) {
+class ExcludeGroup(name: String) : AbstractMaterialGroup(name) {
     override fun createDefaultSet(): EnumSet<Material> {
         return EnumSet.allOf(Material::class.java)
     }
 
-    private val includedGroup = HashSet<AbstractMaterialGroup>()
+    private var includedGroup: MutableSet<AbstractMaterialGroup> = HashSet()
+    private val groupItems by lazy { createDefaultSet() }
 
     override fun isReferencing(other: AbstractMaterialGroup): Boolean {
         for (materialGroup in includedGroup.iterator()) {
-            if((materialGroup == other) || (materialGroup.isReferencing(other))){
+            if ((materialGroup == other) || (materialGroup.isReferencing(other))) {
                 return true
             }
         }
@@ -21,11 +22,33 @@ class ExcludeGroup(name: String): AbstractMaterialGroup(name) {
 
     override fun addToPolicy(mat: Material) {
         includedMaterial.remove(mat)
+        groupItems.remove(mat)
     }
 
     override fun addToPolicy(other: AbstractMaterialGroup) {
         includedGroup.add(other)
-        includedMaterial.removeAll(other.getSet())
+        groupItems.removeAll(other.getMaterials())
+    }
+
+    override fun setGroups(groups: MutableSet<AbstractMaterialGroup>) {
+        groupItems.clear()
+        groupItems.addAll(includedMaterial)
+
+        includedGroup.clear()
+        groups.forEach { group ->
+            if (!group.isReferencing(this)) {
+                includedGroup.add(group)
+                groupItems.removeAll(group.getMaterials())
+            }
+        }
+    }
+
+    override fun getGroups(): MutableSet<AbstractMaterialGroup> {
+        return includedGroup
+    }
+
+    override fun getMaterials(): EnumSet<Material> {
+        return groupItems
     }
 
 

src/main/kotlin/xyz/alexcrea/cuanvil/group/IncludeGroup.kt

@@ -3,16 +3,17 @@ package xyz.alexcrea.cuanvil.group
 import org.bukkit.Material
 import java.util.*
 
-class IncludeGroup(name: String): AbstractMaterialGroup(name) {
+class IncludeGroup(name: String) : AbstractMaterialGroup(name) {
     override fun createDefaultSet(): EnumSet<Material> {
         return EnumSet.noneOf(Material::class.java)
     }
 
-    private val includedGroup = HashSet<AbstractMaterialGroup>()
+    private var includedGroup: MutableSet<AbstractMaterialGroup> = HashSet()
+    private val groupItems by lazy { createDefaultSet() }
 
     override fun isReferencing(other: AbstractMaterialGroup): Boolean {
         for (materialGroup in includedGroup.iterator()) {
-            if((materialGroup == other) || (materialGroup.isReferencing(other))){
+            if ((materialGroup == other) || (materialGroup.isReferencing(other))) {
                 return true
             }
         }
@@ -21,11 +22,45 @@ class IncludeGroup(name: String): AbstractMaterialGroup(name) {
 
     override fun addToPolicy(mat: Material) {
         includedMaterial.add(mat)
+        groupItems.add(mat)
     }
 
     override fun addToPolicy(other: AbstractMaterialGroup) {
         includedGroup.add(other)
-        includedMaterial.addAll(other.getSet())
+        groupItems.addAll(other.getMaterials())
     }
 
+    override fun setGroups(groups: MutableSet<AbstractMaterialGroup>) {
+        groupItems.clear()
+        groupItems.addAll(includedMaterial)
+
+        includedGroup.clear()
+        groups.forEach { group ->
+            if (!group.isReferencing(this)) {
+                includedGroup.add(group)
+                groupItems.addAll(group.getMaterials())
+            }
+        }
+    }
+
+    override fun setNonGroupInheritedMaterials(materials: EnumSet<Material>) {
+        super.setNonGroupInheritedMaterials(materials)
+        // Update group items
+        groupItems.clear()
+        groupItems.addAll(includedMaterial)
+
+        includedGroup.forEach { group ->
+            groupItems.addAll(group.getMaterials())
+        }
+    }
+
+    override fun getGroups(): MutableSet<AbstractMaterialGroup> {
+        return includedGroup
+    }
+
+    override fun getMaterials(): EnumSet<Material> {
+        return groupItems
+    }
+
+
 }

src/main/kotlin/xyz/alexcrea/cuanvil/group/ItemGroupManager.kt

@@ -10,42 +10,47 @@ class ItemGroupManager {
     companion object {
         // Path for group type
         private const val GROUP_TYPE_PATH = "type"
+
         // Path for included items list
         private const val MATERIAL_LIST_PATH = "items"
+
         // Path for included groups list
         private const val GROUP_LIST_PATH = "groups"
+
         // Temporary list of elements in default config that are use in future
-        private val FUTURE_MATERIAL = setOf("PIGLIN_HEAD","BRUSH")
+        private val FUTURE_MATERIAL = setOf("PIGLIN_HEAD", "BRUSH")
     }
 
-    private lateinit var groupMap : HashMap<String, AbstractMaterialGroup>
+    lateinit var groupMap: LinkedHashMap<String, AbstractMaterialGroup>
 
     // Read and create material groups
-    fun prepareGroups(config: ConfigurationSection){
+    fun prepareGroups(config: ConfigurationSection) {
-        groupMap = HashMap()
+        groupMap = LinkedHashMap()
 
         val keys = config.getKeys(false)
         for (key in keys) {
-            if(groupMap.containsKey(key))
+            if (groupMap.containsKey(key))
                 continue
             createGroup(config, keys, key)
         }
     }
 
     // Create group by key
-    private fun createGroup(config: ConfigurationSection,
+    private fun createGroup(
-                            keys: Set<String>,
+        config: ConfigurationSection,
-                            key: String): AbstractMaterialGroup {
+        keys: Set<String>,
+        key: String
+    ): AbstractMaterialGroup {
         val groupSection = config.getConfigurationSection(key)!!
-        val groupType = groupSection.getString(GROUP_TYPE_PATH,null)
+        val groupType = groupSection.getString(GROUP_TYPE_PATH, null)
 
         // Create Material group according to the group type
         val group: AbstractMaterialGroup
-        if(GroupType.EXCLUDE.equal(groupType)){
+        if (GroupType.EXCLUDE.equal(groupType)) {
             group = ExcludeGroup(key)
-        }else {
+        } else {
             group = IncludeGroup(key)
-            if(!GroupType.INCLUDE.equal(groupType)){
+            if (!GroupType.INCLUDE.equal(groupType)) {
                 CustomAnvil.instance.logger.warning("Group $key have an invalid group type. default to Include.")
             }
         }
@@ -56,20 +61,23 @@ class ItemGroupManager {
     }
 
     // Read Group elements
-    private fun readGroup(group: AbstractMaterialGroup,
+    private fun readGroup(
-                          groupSection: ConfigurationSection,
+        group: AbstractMaterialGroup,
-                          config: ConfigurationSection,
+        groupSection: ConfigurationSection,
-                          keys: Set<String>){
+        config: ConfigurationSection,
+        keys: Set<String>
+    ) {
         // Read material to include in this group policy
         val materialList = groupSection.getStringList(MATERIAL_LIST_PATH)
         for (materialTemp in materialList) {
             val materialName = materialTemp.uppercase(Locale.getDefault())
             val material = Material.getMaterial(materialName)
-            if(material == null){
+            if (material == null) {
                 // Check if we should warn the user
-                if(materialName !in FUTURE_MATERIAL){
+                if (materialName !in FUTURE_MATERIAL) {
                     CustomAnvil.instance.logger.warning(
-                        "Unknown material $materialTemp on group ${group.getName()}")
+                        "Unknown material $materialTemp on group ${group.getName()}"
+                    )
 
                 }
                 continue
@@ -81,23 +89,26 @@ class ItemGroupManager {
         // please note the group name is case-sensitive.
         val groupList = groupSection.getStringList(GROUP_LIST_PATH)
         for (groupName in groupList) {
-            if(groupName !in keys){
+            if (groupName !in keys) {
                 CustomAnvil.instance.logger.warning(
-                    "Group $groupName do not exist but is included in group ${group.getName()}")
+                    "Group $groupName do not exist but is included in group ${group.getName()}"
+                )
                 continue
             }
             // Get other group or create it if not yet created
-            val otherGroup = if(!groupMap.containsKey(groupName)){
+            val otherGroup = if (!groupMap.containsKey(groupName)) {
-                createGroup(config,keys,groupName)
+                createGroup(config, keys, groupName)
-            }else{
+            } else {
                 groupMap[groupName]!!
             }
             // Avoid self reference or it will create an infinite loop
-            if(otherGroup.isReferencing(group)){
+            if (otherGroup.isReferencing(group)) {
                 CustomAnvil.instance.logger.warning(
-                    "Group $groupName is on a reference loop with group ${group.getName()} !")
+                    "Group $groupName is on a reference loop with group ${group.getName()} !"
+                )
                 CustomAnvil.instance.logger.warning(
-                    "Please fix it in your item_groups config or the plugin will probably not work as expected.")
+                    "Please fix it in your item_groups config or the plugin will probably not work as expected."
+                )
                 continue
             }
 
@@ -120,10 +131,10 @@ enum class GroupType(private val groupID: String) {
     ;
 
     // Test if string is equal to the groupID of this enum
-    fun equal(toTest: String?): Boolean{
+    fun equal(toTest: String?): Boolean {
-        if(toTest == null)
+        if (toTest == null)
             return false
-        return  groupID.contentEquals(toTest.lowercase(Locale.getDefault()))
+        return groupID.contentEquals(toTest.lowercase(Locale.getDefault()))
     }
 
 }

src/main/kotlin/xyz/alexcrea/cuanvil/listener/ChatEventListener.kt

@@ -0,0 +1,47 @@
+package xyz.alexcrea.cuanvil.listener
+
+import io.delilaheve.CustomAnvil
+import org.bukkit.Bukkit
+import org.bukkit.entity.HumanEntity
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.player.AsyncPlayerChatEvent
+import org.bukkit.event.player.PlayerQuitEvent
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+import java.util.function.Consumer
+
+class ChatEventListener : Listener {
+
+    private val playerListenMap: ConcurrentHashMap<UUID, Consumer<String?>> = ConcurrentHashMap()
+
+    fun setListenedCallback(playeruuid: UUID, callback: Consumer<String?>) {
+        playerListenMap[playeruuid] = callback
+    }
+
+    fun setListenedCallback(player: HumanEntity, callback: Consumer<String?>) {
+        setListenedCallback(player.uniqueId, callback)
+    }
+
+    @EventHandler
+    fun onQuit(event: PlayerQuitEvent) {
+        val eventCallback = playerListenMap.remove(event.player.uniqueId) ?: return
+        eventCallback.accept(null)
+
+    }
+
+    @EventHandler
+    fun onChat(event: AsyncPlayerChatEvent) {
+        if (event.isCancelled) return
+        val player = event.player
+        val eventCallback = playerListenMap.remove(player.uniqueId) ?: return
+
+        event.isCancelled = true
+
+        // sync callback with default server thread
+        Bukkit.getScheduler().runTask(CustomAnvil.instance, Runnable {
+            eventCallback.accept(event.message)
+        })
+    }
+
+}

src/main/kotlin/xyz/alexcrea/cuanvil/util/MetricsUtil.kt

@@ -31,12 +31,11 @@ object MetricsUtil {
      */
     private fun getHashFromKey(section: ConfigurationSection, key: String): Int {
         // Key is assumend to exist
-        val resultHash: Int
+        val resultHash = if (section.isConfigurationSection(key)) {
-        if(section.isConfigurationSection(key)){
             val sectionResult = getConfigurationHash(section.getConfigurationSection(key)!!)
-            resultHash = key.hashCode() xor sectionResult
+            key.hashCode() xor sectionResult
-        }else{
+        } else {
-            resultHash = key.hashCode() xor section.getString(key).hashCode()
+            key.hashCode() xor section.getString(key).hashCode()
         }
         return resultHash.hashCode()
     }
@@ -47,7 +46,7 @@ object MetricsUtil {
     private fun getConfigurationHash(section: ConfigurationSection): Int {
         var resultHash = 0
         for (key in section.getKeys(false)) {
-            resultHash = resultHash xor getHashFromKey(section,key)
+            resultHash = resultHash xor getHashFromKey(section, key)
         }
         return resultHash
     }
@@ -55,10 +54,10 @@ object MetricsUtil {
     /**
      * Get hash value of the default config
      */
-    private fun testBaseConfig(defaultConfig: ConfigurationSection): Int{
+    private fun testBaseConfig(defaultConfig: ConfigurationSection): Int {
         var result = 0
         for (key in ConfigOptions.getBasicConfigKeys()) {
-            result = result xor getHashFromKey(defaultConfig,key)
+            result = result xor getHashFromKey(defaultConfig, key)
         }
         return result
     }
@@ -66,7 +65,7 @@ object MetricsUtil {
     /**
      * Test if the used configuration is the default config
      */
-    fun testIfConfigIsDefault(){
+    fun testIfConfigIsDefault() {
         // Calculate hash of config
         val baseConfig = testBaseConfig(ConfigHolder.DEFAULT_CONFIG.config)
         val limitEnchantConfig = getHashFromKey(ConfigHolder.DEFAULT_CONFIG.config, ConfigOptions.ENCHANT_LIMIT_ROOT)
@@ -77,37 +76,49 @@ object MetricsUtil {
         // Test if default
         isDefaultBaseConfig = baseConfigHash == baseConfig
         isDefaultEnchantLimitsConfig = enchantLimitsConfigHash == limitEnchantConfig
-        isDefaultEnchantValuesConfig = enchantValuesConfigHash  == enchantValueConfig
+        isDefaultEnchantValuesConfig = enchantValuesConfigHash == enchantValueConfig
         isDefaultEnchantConflictConfig = enchantConflictConfigHash == enchantConflictConfig
         isDefaultItemGroupsConfig = itemGroupsConfigHash == itemGroupConfig
         isDefaultUnitRepairItemConfig = unitRepairItemConfigHash == unitRepairConfig
         // If not default and debug flag active, print the hash.
-        if(ConfigOptions.debugLog){
+        if (ConfigOptions.debugLog) {
-            if(!isDefaultBaseConfig){CustomAnvil.log("baseConfig: $baseConfig")}
+            if (!isDefaultBaseConfig) {
-            if(!isDefaultEnchantLimitsConfig){CustomAnvil.log("limitEnchantConfig: $limitEnchantConfig")}
+                CustomAnvil.log("baseConfig: $baseConfig")
-            if(!isDefaultEnchantValuesConfig){CustomAnvil.log("enchantValueConfig: $enchantValueConfig")}
+            }
-            if(!isDefaultEnchantConflictConfig){CustomAnvil.log("enchantConflictConfig: $enchantConflictConfig")}
+            if (!isDefaultEnchantLimitsConfig) {
-            if(!isDefaultItemGroupsConfig){CustomAnvil.log("itemGroupConfig: $itemGroupConfig")}
+                CustomAnvil.log("limitEnchantConfig: $limitEnchantConfig")
-            if(!isDefaultUnitRepairItemConfig){CustomAnvil.log("unitRepairConfig: $unitRepairConfig")}
+            }
+            if (!isDefaultEnchantValuesConfig) {
+                CustomAnvil.log("enchantValueConfig: $enchantValueConfig")
+            }
+            if (!isDefaultEnchantConflictConfig) {
+                CustomAnvil.log("enchantConflictConfig: $enchantConflictConfig")
+            }
+            if (!isDefaultItemGroupsConfig) {
+                CustomAnvil.log("itemGroupConfig: $itemGroupConfig")
+            }
+            if (!isDefaultUnitRepairItemConfig) {
+                CustomAnvil.log("unitRepairConfig: $unitRepairConfig")
+            }
         }
 
     }
 
-    fun notifyChange(holder: ConfigHolder, path: String){
+    fun notifyChange(holder: ConfigHolder, path: String) {
-        if(ConfigHolder.DEFAULT_CONFIG.equals(holder)){
+        if (ConfigHolder.DEFAULT_CONFIG.equals(holder)) {
-            if(path.startsWith(ConfigOptions.ENCHANT_LIMIT_ROOT+".")){
+            if (path.startsWith(ConfigOptions.ENCHANT_LIMIT_ROOT + ".")) {
-                isDefaultEnchantLimitsConfig = false;
+                isDefaultEnchantLimitsConfig = false
-            }else if(path.startsWith(ConfigOptions.ENCHANT_VALUES_ROOT+".")){
+            } else if (path.startsWith(ConfigOptions.ENCHANT_VALUES_ROOT + ".")) {
-                isDefaultEnchantValuesConfig = false;
+                isDefaultEnchantValuesConfig = false
-            }else{
+            } else {
-                isDefaultBaseConfig = false;
+                isDefaultBaseConfig = false
             }
-        }else if(ConfigHolder.CONFLICT_HOLDER.equals(holder)){
+        } else if (ConfigHolder.CONFLICT_HOLDER.equals(holder)) {
-            isDefaultEnchantConflictConfig = false;
+            isDefaultEnchantConflictConfig = false
-        }else if(ConfigHolder.ITEM_GROUP_HOLDER.equals(holder)){
+        } else if (ConfigHolder.ITEM_GROUP_HOLDER.equals(holder)) {
-            isDefaultItemGroupsConfig = false;
+            isDefaultItemGroupsConfig = false
-        }else if(ConfigHolder.UNIT_REPAIR_HOLDER.equals(holder)){
+        } else if (ConfigHolder.UNIT_REPAIR_HOLDER.equals(holder)) {
-            isDefaultUnitRepairItemConfig = false;
+            isDefaultUnitRepairItemConfig = false
         }
     }
 

src/main/kotlin/xyz/alexcrea/cuanvil/util/UnitRepairUtil.kt

@@ -8,6 +8,7 @@ object UnitRepairUtil {
 
     // Default value for user set default unit repair %
     private const val DEFAULT_DEFAULT_UNIT_REPAIR = 0.25
+
     // Path to user default unit repair value
     private const val UNIT_REPAIR_DEFAULT_PATH = "default_repair_amount"
 
@@ -18,23 +19,23 @@ object UnitRepairUtil {
     fun ItemStack.getRepair(
         other: ItemStack?
     ): Double? {
-        if(other == null) return null
+        if (other == null) return null
         val config = ConfigHolder.UNIT_REPAIR_HOLDER.config
         // Get configuration section if exist
         val otherName = other.type.name.uppercase()
         var section = config.getConfigurationSection(otherName)
-        if(section == null){
+        if (section == null) {
             section = config.getConfigurationSection(otherName.lowercase())
-            if(section == null) return null
+            if (section == null) return null
 
         }
         // Get repair amount
         var userDefault = config.getDouble(UNIT_REPAIR_DEFAULT_PATH, DEFAULT_DEFAULT_UNIT_REPAIR)
-        if(userDefault <= 0){
+        if (userDefault <= 0) {
             userDefault = DEFAULT_DEFAULT_UNIT_REPAIR
         }
 
-        return getRepairAmount(this,section,userDefault)
+        return getRepairAmount(this, section, userDefault)
     }
 
     /**
@@ -42,16 +43,16 @@ object UnitRepairUtil {
      * null if not found.
      * If value is set to less than or equal to 0 then it will be set to default
      */
-    private fun getRepairAmount(item: ItemStack, section: ConfigurationSection, default: Double): Double?{
+    private fun getRepairAmount(item: ItemStack, section: ConfigurationSection, default: Double): Double? {
         val itemName = item.type.name.uppercase()
-        val repairValue = if(section.isDouble(itemName)){
+        val repairValue = if (section.isDouble(itemName)) {
             section.getDouble(itemName)
-        }else if(section.isDouble(itemName.lowercase())){
+        } else if (section.isDouble(itemName.lowercase())) {
             section.getDouble(itemName.lowercase())
-        }else{
+        } else {
             return null
         }
-        if(repairValue <= 0)
+        if (repairValue <= 0)
             return default
         return repairValue
     }

src/main/resources/config.yml

@@ -220,3 +220,6 @@ enchant_values:
 
 # Whether to show debug logging
 debug_log: false
+
+# Whether to show verbose debug logging
+debug_log_verbose: false

src/main/resources/enchant_conflict.yml

@@ -12,159 +12,159 @@
 # ----------------------------------------------------
 
 restriction_aqua_affinity:
-  enchantments: [aqua_affinity]
+  enchantments: [ aqua_affinity ]
-  notAffectedGroups: [enchanted_book, helmets]
+  notAffectedGroups: [ enchanted_book, helmets ]
 
 restriction_bane_of_arthropods:
-  enchantments: [bane_of_arthropods]
+  enchantments: [ bane_of_arthropods ]
-  notAffectedGroups: [enchanted_book, melee_weapons]
+  notAffectedGroups: [ enchanted_book, melee_weapons ]
 
 restriction_blast_protection:
-  enchantments: [blast_protection]
+  enchantments: [ blast_protection ]
-  notAffectedGroups: [enchanted_book, armors]
+  notAffectedGroups: [ enchanted_book, armors ]
 
 restriction_channeling:
-  enchantments: [channeling]
+  enchantments: [ channeling ]
-  notAffectedGroups: [enchanted_book, trident]
+  notAffectedGroups: [ enchanted_book, trident ]
 
 restriction_binding_curse:
-  enchantments: [binding_curse]
+  enchantments: [ binding_curse ]
-  notAffectedGroups: [enchanted_book, wearable]
+  notAffectedGroups: [ enchanted_book, wearable ]
 
 restriction_vanishing_curse:
-  enchantments: [vanishing_curse]
+  enchantments: [ vanishing_curse ]
-  notAffectedGroups: [enchanted_book, can_vanish]
+  notAffectedGroups: [ enchanted_book, can_vanish ]
 
 restriction_depth_strider:
-  enchantments: [depth_strider]
+  enchantments: [ depth_strider ]
-  notAffectedGroups: [enchanted_book, boots]
+  notAffectedGroups: [ enchanted_book, boots ]
 
 restriction_efficiency:
-  enchantments: [efficiency]
+  enchantments: [ efficiency ]
-  notAffectedGroups: [enchanted_book, tools,  shears]
+  notAffectedGroups: [ enchanted_book, tools,  shears ]
 
 restriction_feather_falling:
-  enchantments: [feather_falling]
+  enchantments: [ feather_falling ]
-  notAffectedGroups: [enchanted_book, boots]
+  notAffectedGroups: [ enchanted_book, boots ]
 
 restriction_fire_aspect:
-  enchantments: [fire_aspect]
+  enchantments: [ fire_aspect ]
-  notAffectedGroups: [enchanted_book, swords]
+  notAffectedGroups: [ enchanted_book, swords ]
 
 restriction_fire_protection:
-  enchantments: [fire_protection]
+  enchantments: [ fire_protection ]
-  notAffectedGroups: [enchanted_book, armors]
+  notAffectedGroups: [ enchanted_book, armors ]
 
 restriction_flame:
-  enchantments: [flame]
+  enchantments: [ flame ]
-  notAffectedGroups: [enchanted_book, bow]
+  notAffectedGroups: [ enchanted_book, bow ]
 
 restriction_fortune:
-  enchantments: [fortune]
+  enchantments: [ fortune ]
-  notAffectedGroups: [enchanted_book, tools]
+  notAffectedGroups: [ enchanted_book, tools ]
 
 restriction_frost_walker:
-  enchantments: [frost_walker]
+  enchantments: [ frost_walker ]
-  notAffectedGroups: [enchanted_book, boots]
+  notAffectedGroups: [ enchanted_book, boots ]
 
 restriction_impaling:
-  enchantments: [impaling]
+  enchantments: [ impaling ]
-  notAffectedGroups: [enchanted_book, trident]
+  notAffectedGroups: [ enchanted_book, trident ]
 
 restriction_infinity:
-  enchantments: [infinity]
+  enchantments: [ infinity ]
-  notAffectedGroups: [enchanted_book, bow]
+  notAffectedGroups: [ enchanted_book, bow ]
 
 restriction_knockback:
-  enchantments: [knockback]
+  enchantments: [ knockback ]
-  notAffectedGroups: [enchanted_book, swords]
+  notAffectedGroups: [ enchanted_book, swords ]
 
 restriction_looting:
-  enchantments: [looting]
+  enchantments: [ looting ]
-  notAffectedGroups: [enchanted_book, swords]
+  notAffectedGroups: [ enchanted_book, swords ]
 
 restriction_loyalty:
-  enchantments: [loyalty]
+  enchantments: [ loyalty ]
-  notAffectedGroups: [enchanted_book, trident]
+  notAffectedGroups: [ enchanted_book, trident ]
 
 restriction_lure:
-  enchantments: [lure]
+  enchantments: [ lure ]
-  notAffectedGroups: [enchanted_book, fishing_rod]
+  notAffectedGroups: [ enchanted_book, fishing_rod ]
 
 restriction_mending:
-  enchantments: [mending]
+  enchantments: [ mending ]
-  notAffectedGroups: [enchanted_book, can_unbreak]
+  notAffectedGroups: [ enchanted_book, can_unbreak ]
 
 restriction_multishot:
-  enchantments: [multishot]
+  enchantments: [ multishot ]
-  notAffectedGroups: [enchanted_book, crossbow]
+  notAffectedGroups: [ enchanted_book, crossbow ]
 
 restriction_piercing:
-  enchantments: [piercing]
+  enchantments: [ piercing ]
-  notAffectedGroups: [enchanted_book, crossbow]
+  notAffectedGroups: [ enchanted_book, crossbow ]
 
 restriction_power:
-  enchantments: [power]
+  enchantments: [ power ]
-  notAffectedGroups: [enchanted_book, bow]
+  notAffectedGroups: [ enchanted_book, bow ]
 
 restriction_projectile_protection:
-  enchantments: [projectile_protection]
+  enchantments: [ projectile_protection ]
-  notAffectedGroups: [enchanted_book, armors]
+  notAffectedGroups: [ enchanted_book, armors ]
 
 restriction_protection:
-  enchantments: [protection]
+  enchantments: [ protection ]
-  notAffectedGroups: [enchanted_book, armors]
+  notAffectedGroups: [ enchanted_book, armors ]
 
 restriction_punch:
-  enchantments: [punch]
+  enchantments: [ punch ]
-  notAffectedGroups: [enchanted_book, bow]
+  notAffectedGroups: [ enchanted_book, bow ]
 
 restriction_quick_charge:
-  enchantments: [quick_charge]
+  enchantments: [ quick_charge ]
-  notAffectedGroups: [enchanted_book, crossbow]
+  notAffectedGroups: [ enchanted_book, crossbow ]
 
 restriction_respiration:
-  enchantments: [respiration]
+  enchantments: [ respiration ]
-  notAffectedGroups: [enchanted_book, helmets]
+  notAffectedGroups: [ enchanted_book, helmets ]
 
 restriction_riptide:
-  enchantments: [riptide]
+  enchantments: [ riptide ]
-  notAffectedGroups: [enchanted_book, trident]
+  notAffectedGroups: [ enchanted_book, trident ]
 
 restriction_sharpness:
-  enchantments: [sharpness]
+  enchantments: [ sharpness ]
-  notAffectedGroups: [enchanted_book, melee_weapons]
+  notAffectedGroups: [ enchanted_book, melee_weapons ]
 
 restriction_silk_touch:
-  enchantments: [silk_touch]
+  enchantments: [ silk_touch ]
-  notAffectedGroups: [enchanted_book, tools]
+  notAffectedGroups: [ enchanted_book, tools ]
 
 restriction_smite:
-  enchantments: [smite]
+  enchantments: [ smite ]
-  notAffectedGroups: [enchanted_book, melee_weapons]
+  notAffectedGroups: [ enchanted_book, melee_weapons ]
 
 restriction_soul_speed:
-  enchantments: [soul_speed]
+  enchantments: [ soul_speed ]
-  notAffectedGroups: [enchanted_book, boots]
+  notAffectedGroups: [ enchanted_book, boots ]
 
 restriction_sweeping:
-  enchantments: [sweeping]
+  enchantments: [ sweeping ]
-  notAffectedGroups: [enchanted_book, swords]
+  notAffectedGroups: [ enchanted_book, swords ]
 
 # Do not exist in 1.18,  that mean useInFuture will be set to true
 # useInFuture set to true also mean it will not warn if there is an issue
 restriction_swift_sneak:
   useInFuture: true
-  enchantments: [swift_sneak]
+  enchantments: [ swift_sneak ]
-  notAffectedGroups: [enchanted_book, boots]
+  notAffectedGroups: [ enchanted_book, boots ]
 
 restriction_thorns:
-  enchantments: [thorns]
+  enchantments: [ thorns ]
-  notAffectedGroups: [enchanted_book, armors]
+  notAffectedGroups: [ enchanted_book, armors ]
 
 restriction_unbreaking:
-  enchantments: [unbreaking]
+  enchantments: [ unbreaking ]
-  notAffectedGroups: [enchanted_book, can_unbreak]
+  notAffectedGroups: [ enchanted_book, can_unbreak ]
 
 # ----------------------------------------------------
 # Now we have conflicts about enchantment Incompatibility
@@ -178,7 +178,7 @@ sword_enchant_conflict:
     - bane_of_arthropods
     - smite
     - sharpness
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
 protection_enchant_conflict:
@@ -187,48 +187,52 @@ protection_enchant_conflict:
     - fire_protection
     - projectile_protection
     - protection
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
 trident_conflict1:
   enchantments:
     - channeling
     - riptide
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
 trident_conflict2:
   enchantments:
     - loyalty
     - riptide
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
 boot_conflict:
   enchantments:
     - depth_strider
     - frost_walker
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
 tool_conflict:
   enchantments:
     - fortune
     - silk_touch
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
 bow_conflict:
   enchantments:
     - mending
     - infinity
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
 crossbow_conflict:
   enchantments:
     - multishot
     - piercing
-  notAffectedGroups: []
+  notAffectedGroups: [ ]
   maxEnchantmentBeforeConflict: 1
 
+# ----------------------------------------------------
+# Bellow is for custom conflicts.
+# This is also where conflict create from the gui will be placed.
+# ----------------------------------------------------

src/main/resources/plugin.yml

@@ -1,11 +1,11 @@
 main: io.delilaheve.CustomAnvil
 name: CustomAnvil
 prefix: "Custom Anvil"
-version: 1.3.2-A1
+version: 1.3.2-A2
 description: Allow to customise anvil mechanics
 api-version: 1.18
 load: POSTWORLD
-authors: [DelilahEve, alexcrea]
+authors: [ DelilahEve, alexcrea ]
 libraries:
   - org.jetbrains.kotlin:kotlin-stdlib:1.6.21
   - com.github.stefvanschie.inventoryframework:IF:0.10.13