Various rewrites, refinements, and improvements

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandApply.kt

@@ -3,7 +3,7 @@ package com.willfp.reforges.commands
 import com.willfp.eco.core.EcoPlugin
 import com.willfp.eco.core.command.impl.Subcommand
 import com.willfp.reforges.reforges.Reforges
-import com.willfp.reforges.util.ReforgeUtils
+import com.willfp.reforges.util.reforge
 import org.bukkit.Bukkit
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
@@ -27,7 +27,7 @@ class CommandApply(
 
         if (sender is Player) {
             val item = sender.inventory.itemInMainHand
-            ReforgeUtils.setReforge(item, reforge)
+            item.reforge = reforge
             sender.sendMessage(
                 plugin.langYml.getMessage("applied-reforge")
                     .replace("%reforge%", reforge.name)
@@ -45,7 +45,7 @@ class CommandApply(
                 return
             }
 
-            ReforgeUtils.setReforge(player.inventory.itemInMainHand, reforge)
+            player.inventory.itemInMainHand.reforge = reforge
             sender.sendMessage(
                 plugin.langYml.getMessage("applied-reforge")
                     .replace("%reforge%", reforge.name)

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandOpen.kt

@@ -2,7 +2,7 @@ package com.willfp.reforges.commands
 
 import com.willfp.eco.core.EcoPlugin
 import com.willfp.eco.core.command.impl.PluginCommand
-import com.willfp.reforges.gui.ReforgeGUI.menu
+import com.willfp.reforges.gui.ReforgeGUI
 import org.bukkit.Bukkit
 import org.bukkit.Sound
 import org.bukkit.command.CommandSender
@@ -29,7 +29,8 @@ class CommandOpen(
                 plugin.configYml.getDouble("gui.open-sound.pitch").toFloat()
             )
         }
-        menu.open(player)
+
+        ReforgeGUI.open(player)
     }
 
     override fun tabComplete(sender: CommandSender, args: List<String>): List<String> {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReforge.kt

@@ -2,7 +2,7 @@ package com.willfp.reforges.commands
 
 import com.willfp.eco.core.EcoPlugin
 import com.willfp.eco.core.command.impl.PluginCommand
-import com.willfp.reforges.gui.ReforgeGUI.menu
+import com.willfp.reforges.gui.ReforgeGUI
 import org.bukkit.Sound
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
@@ -20,6 +20,7 @@ class CommandReforge(
                 plugin.configYml.getDouble("gui.open-sound.pitch").toFloat()
             )
         }
-        menu.open(player)
+
+        ReforgeGUI.open(player)
     }
-}
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/display/ReforgesDisplay.kt

@@ -6,32 +6,18 @@ import com.willfp.eco.core.display.DisplayPriority
 import com.willfp.eco.core.fast.FastItemStack
 import com.willfp.eco.core.fast.fast
 import com.willfp.eco.util.SkullUtils
-import com.willfp.eco.util.StringUtils
 import com.willfp.reforges.ReforgesPlugin
 import com.willfp.reforges.reforges.ReforgeTarget
-import com.willfp.reforges.util.ReforgeUtils
+import com.willfp.reforges.util.reforge
+import com.willfp.reforges.util.reforgeStone
+import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.TextReplacementConfig
-import net.kyori.adventure.text.format.TextDecoration
-import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.SkullMeta
-import org.bukkit.persistence.PersistentDataType
 
 @Suppress("DEPRECATION")
 class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin, DisplayPriority.HIGH) {
-    /**
-     * Deprecated
-     */
-    @Deprecated("Use PDC components!")
-    private val replacement = TextReplacementConfig.builder()
-        .match("§w(.+)§w")
-        .replacement("")
-        .build()
-
-    private val originalComponentKey = plugin.namespacedKeyFactory.create("real_name")
-    private val serializer = GsonComponentSerializer.gson()
-
     override fun display(
         itemStack: ItemStack,
         player: Player?,
@@ -41,7 +27,7 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
 
         val fast = itemStack.fast()
 
-        val stone = ReforgeUtils.getReforgeStone(fast.persistentDataContainer)
+        val stone = fast.persistentDataContainer.reforgeStone
 
         if (target.isEmpty() && stone == null) {
             return
@@ -51,7 +37,7 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
 
         val lore = fastItemStack.lore
 
-        val reforge = ReforgeUtils.getReforge(fast.persistentDataContainer)
+        val reforge = fast.persistentDataContainer.reforge
 
         if (reforge == null && stone == null && target != null) {
             if (plugin.configYml.getBool("reforge.show-reforgable")) {
@@ -103,18 +89,11 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
                 lore.addAll(addLore)
             }
             if (plugin.configYml.getBool("reforge.display-in-name")) {
-                val displayName = fastItemStack.displayNameComponent.replaceText(replacement)
+                val displayName = fastItemStack.displayNameComponent
 
-                val newName = StringUtils.toComponent("${reforge.name} ")
+                val newName = reforge.namePrefixComponent.append(displayName)
-                    .decoration(TextDecoration.ITALIC, false).append(displayName)
 
                 fastItemStack.setDisplayName(newName)
-
-                fastItemStack.persistentDataContainer.set(
-                    originalComponentKey,
-                    PersistentDataType.STRING,
-                    serializer.serialize(displayName)
-                )
             }
 
 
@@ -132,15 +111,24 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
     }
 
     override fun revert(itemStack: ItemStack) {
-        ReforgeTarget.getForItem(itemStack) ?: return
+        val reforge = itemStack.reforge ?: return
+        ReforgeTarget.getForItem(itemStack).ifEmpty { return }
 
         val fis = FastItemStack.wrap(itemStack)
 
-        if (plugin.configYml.getBool("reforge.display-in-name")) {
+        if (!plugin.configYml.getBool("reforge.display-in-name")) {
-            val originalName =
+            return
-                fis.persistentDataContainer.get(originalComponentKey, PersistentDataType.STRING) ?: return
-            fis.persistentDataContainer.remove(originalComponentKey)
-            fis.setDisplayName(serializer.deserialize(originalName).replaceText(replacement))
         }
+
+        val name = fis.displayNameComponent
+
+        name.replaceText(
+            TextReplacementConfig.builder()
+                .matchLiteral("${reforge.name} ")
+                .replacement(Component.empty())
+                .build()
+        )
+
+        fis.setDisplayName(name)
     }
 }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/gui/ReforgeGUI.kt

@@ -17,8 +17,12 @@ import com.willfp.eco.util.NumberUtils
 import com.willfp.reforges.reforges.PriceMultipliers
 import com.willfp.reforges.reforges.Reforge
 import com.willfp.reforges.reforges.ReforgeTarget
+import com.willfp.reforges.reforges.util.MetadatedReforgeStatus
 import com.willfp.reforges.util.ReforgeStatus
-import com.willfp.reforges.util.ReforgeUtils
+import com.willfp.reforges.util.getRandomReforge
+import com.willfp.reforges.util.reforge
+import com.willfp.reforges.util.reforgeStone
+import com.willfp.reforges.util.timesReforged
 import org.bukkit.Material
 import org.bukkit.Sound
 import org.bukkit.entity.Player
@@ -30,6 +34,34 @@ import kotlin.math.pow
 object ReforgeGUI {
     private lateinit var menu: Menu
 
+    private fun Menu.getReforgeStatus(player: Player): MetadatedReforgeStatus {
+        val captive = this.getCaptiveItems(player)
+        val item = captive.getOrNull(0)
+        val stone = captive.getOrNull(1)
+
+        val targets = mutableListOf<ReforgeTarget>()
+
+        var cost = 0.0
+        val status = if (item == null || item.type == Material.AIR) {
+            ReforgeStatus.NO_ITEM
+        } else {
+            targets.addAll(ReforgeTarget.getForItem(item))
+            if (targets.isEmpty()) {
+                ReforgeStatus.INVALID_ITEM
+            } else {
+                val reforgeStone = stone.reforgeStone
+                if (reforgeStone != null && reforgeStone.canBeAppliedTo(item)) {
+                    cost = reforgeStone.stonePrice.toDouble()
+                    ReforgeStatus.ALLOW_STONE
+                } else {
+                    ReforgeStatus.ALLOW
+                }
+            }
+        }
+
+        return MetadatedReforgeStatus(status, cost)
+    }
+
     @JvmStatic
     fun open(player: Player) {
         menu.open(player)
@@ -40,11 +72,12 @@ object ReforgeGUI {
     fun update(plugin: EcoPlugin) {
         val activatorSlot = slot(ItemStack(Material.ANVIL)) {
             setModifier { player, menu, _ ->
-                val (status, specialCost) = ReforgeUtils.getStatus(menu.getCaptiveItems(player))
+                val (status, specialCost) = menu.getReforgeStatus(player)
 
                 val cost = when {
                     status == ReforgeStatus.ALLOW || (status == ReforgeStatus.ALLOW_STONE && specialCost < 0) -> {
-                        val amountOfReforges = ReforgeUtils.getReforges(menu.getCaptiveItems(player)[0])
+                        val amountOfReforges = menu.getCaptiveItems(player)[0].timesReforged
+
                         plugin.configYml.getDouble("reforge.cost") *
                                 plugin.configYml.getDouble("reforge.cost-exponent").pow(amountOfReforges) *
                                 PriceMultipliers.getForPlayer(player).multiplier
@@ -58,7 +91,7 @@ object ReforgeGUI {
                 var xpCost = plugin.configYml.getInt("reforge.xp-cost")
                 if (status == ReforgeStatus.ALLOW) {
                     val item = menu.getCaptiveItems(player)[0]
-                    val reforges = ReforgeUtils.getReforges(item)
+                    val reforges = item.timesReforged
                     xpCost *= PriceMultipliers.getForPlayer(player).multiplier.toInt()
                     xpCost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble()).toInt()
                 }
@@ -72,7 +105,7 @@ object ReforgeGUI {
                             .replace("%xpcost%", NumberUtils.format(xpCost.toDouble()))
                             .replace(
                                 "%stone%",
-                                ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player)[1])?.name ?: ""
+                                menu.getCaptiveItems(player)[1].reforgeStone?.name ?: ""
                             )
                     }
                 }
@@ -82,17 +115,18 @@ object ReforgeGUI {
                 val player = event.whoClicked as Player
                 val captive = menu.getCaptiveItems(player)
 
-                val toReforge = captive.getOrNull(0) ?: return@onLeftClick
+                val item = captive.getOrNull(0) ?: return@onLeftClick
-                val existingReforge = ReforgeUtils.getReforge(toReforge)
+                val currentReforge = item.reforge
-                val target = ReforgeTarget.getForItem(toReforge)
+                val targets = ReforgeTarget.getForItem(item)
 
                 var reforge: Reforge? = null
                 var usedStone = false
 
+                // Scan for reforge stone
                 if (menu.getCaptiveItems(player).size == 2) {
-                    val stone = ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player)[1])
+                    val stone = menu.getCaptiveItems(player)[1].reforgeStone
                     if (stone != null) {
-                        if (stone.targets.any { it.matches(toReforge) }) {
+                        if (stone.canBeAppliedTo(item)) {
                             reforge = stone
                             usedStone = true
                         }
@@ -100,11 +134,11 @@ object ReforgeGUI {
                 }
 
                 if (reforge == null) {
-                    val existing: MutableList<Reforge> = ArrayList()
+                    val disallowed = mutableListOf<Reforge>()
-                    if (existingReforge != null) {
+                    if (currentReforge != null) {
-                        existing.add(existingReforge)
+                        disallowed.add(currentReforge)
                     }
-                    reforge = ReforgeUtils.getRandomReforge(target, existing)
+                    reforge = targets.getRandomReforge(disallowed = disallowed)
                 }
 
                 if (reforge == null) {
@@ -113,9 +147,10 @@ object ReforgeGUI {
 
                 var cost = 0.0
 
+                val reforges = item.timesReforged
+
                 if (EconomyManager.hasRegistrations()) {
                     cost = plugin.configYml.getDouble("reforge.cost")
-                    val reforges = ReforgeUtils.getReforges(toReforge)
                     cost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble())
                     if (reforge.requiresStone && reforge.stonePrice != -1) {
                         cost = reforge.stonePrice.toDouble()
@@ -136,8 +171,9 @@ object ReforgeGUI {
                         return@onLeftClick
                     }
                 }
+
                 var xpCost = plugin.configYml.getInt("reforge.xp-cost")
-                val reforges = ReforgeUtils.getReforges(toReforge)
+
                 xpCost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble()).toInt()
                 xpCost *= PriceMultipliers.getForPlayer(player).multiplier.toInt()
                 if (player.level < xpCost) {
@@ -158,9 +194,12 @@ object ReforgeGUI {
                     EconomyManager.removeMoney(player, cost)
                 }
                 player.level = player.level - xpCost
+
                 player.sendMessage(plugin.langYml.getMessage("applied-reforge").replace("%reforge%", reforge.name))
-                ReforgeUtils.incrementReforges(toReforge)
+
-                ReforgeUtils.setReforge(toReforge, reforge)
+                item.timesReforged++
+                item.reforge = reforge
+
                 if (usedStone) {
                     val stone = menu.getCaptiveItems(player)[1]
                     stone.itemMeta = null
@@ -175,6 +214,7 @@ object ReforgeGUI {
                         )
                     }
                 }
+
                 if (plugin.configYml.getBool("gui.sound.enabled")) {
                     player.playSound(
                         player.location,
@@ -194,35 +234,33 @@ object ReforgeGUI {
         menu = menu(plugin.configYml.getInt("gui.rows")) {
             setTitle(plugin.langYml.getFormattedString("menu.title"))
             setMask(FillerMask(MaskItems(*maskItems), *maskPattern))
-            modfiy { builder ->
-                val slot = Slot.builder(
-                    ItemStackBuilder(Material.BLACK_STAINED_GLASS_PANE)
-                        .setDisplayName("&r")
-                        .build()
-                ).apply {
-                    setModifier { player, menu, _ ->
-                        val status = ReforgeUtils.getStatus(
-                            menu.getCaptiveItems(player)
-                        ).status
 
-                        if (status == ReforgeStatus.ALLOW || status == ReforgeStatus.ALLOW_STONE) {
+            val slot = slot(
-                            Items.lookup(plugin.configYml.getString("gui.show-allowed.allow-material")).item
+                ItemStackBuilder(Material.BLACK_STAINED_GLASS_PANE)
-                        } else {
+                    .setDisplayName("&r")
-                            Items.lookup(plugin.configYml.getString("gui.show-allowed.deny-material")).item
+                    .build()
-                        }
+            ) {
-                    }
+                setModifier { player, menu, _ ->
-                }.build()
+                    val status = menu.getReforgeStatus(player).status
 
-                val allowedPattern = plugin.configYml.getStrings("gui.show-allowed.pattern")
+                    if (status == ReforgeStatus.ALLOW || status == ReforgeStatus.ALLOW_STONE) {
-                for (i in 1..allowedPattern.size) {
+                        Items.lookup(plugin.configYml.getString("gui.show-allowed.allow-material")).item
-                    val row = allowedPattern[i - 1]
+                    } else {
-                    for (j in 1..9) {
+                        Items.lookup(plugin.configYml.getString("gui.show-allowed.deny-material")).item
-                        if (row[j - 1] != '0') {
-                            builder.setSlot(i, j, slot)
-                        }
                     }
                 }
             }
+
+            val allowedPattern = plugin.configYml.getStrings("gui.show-allowed.pattern")
+            for (i in 1..allowedPattern.size) {
+                val row = allowedPattern[i - 1]
+                for (j in 1..9) {
+                    if (row[j - 1] != '0') {
+                        setSlot(i, j, slot)
+                    }
+                }
+            }
+
             setSlot(
                 plugin.configYml.getInt("gui.item-slot.row"),
                 plugin.configYml.getInt("gui.item-slot.column"),

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/Reforge.kt

@@ -6,11 +6,13 @@ import com.willfp.eco.core.items.CustomItem
 import com.willfp.eco.core.items.Items
 import com.willfp.eco.core.items.builder.ItemStackBuilder
 import com.willfp.eco.core.recipe.Recipes
+import com.willfp.eco.util.StringUtils
 import com.willfp.libreforge.Holder
 import com.willfp.libreforge.conditions.Conditions
 import com.willfp.libreforge.effects.Effects
 import com.willfp.reforges.ReforgesPlugin
-import com.willfp.reforges.util.ReforgeUtils
+import com.willfp.reforges.util.reforgeStone
+import net.kyori.adventure.text.format.TextDecoration
 import org.bukkit.inventory.ItemStack
 import java.util.*
 
@@ -23,6 +25,8 @@ class Reforge(
 
     val name = config.getFormattedString("name")
 
+    val namePrefixComponent = StringUtils.toComponent("$name ").decoration(TextDecoration.ITALIC, false)
+
     val description: List<String> = config.getFormattedStrings("description")
 
     val targets = config.getStrings("targets").mapNotNull { ReforgeTarget.getByName(it) }.toSet()
@@ -50,14 +54,13 @@ class Reforge(
     init {
         Reforges.addNewReforge(this)
 
-        ReforgeUtils.setReforgeStone(stone, this)
+        stone.reforgeStone = this
-
         Display.display(stone)
 
         if (config.getBool("stone.enabled")) {
             CustomItem(
                 plugin.namespacedKeyFactory.create("stone_" + this.id),
-                { test -> ReforgeUtils.getReforgeStone(test) == this },
+                { test -> test.reforgeStone == this },
                 stone
             ).register()
 
@@ -72,6 +75,10 @@ class Reforge(
         }
     }
 
+    fun canBeAppliedTo(item: ItemStack?): Boolean {
+        return targets.any { target -> target.items.any { it.matches(item) } }
+    }
+
     override fun equals(other: Any?): Boolean {
         if (this === other) {
             return true

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/ReforgeArgParser.kt

@@ -3,7 +3,7 @@ package com.willfp.reforges.reforges.util
 import com.willfp.eco.core.items.args.LookupArgParser
 import com.willfp.reforges.reforges.Reforge
 import com.willfp.reforges.reforges.Reforges
-import com.willfp.reforges.util.ReforgeUtils
+import com.willfp.reforges.util.reforge
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.ItemMeta
 import java.util.function.Predicate
@@ -27,16 +27,16 @@ class ReforgeArgParser : LookupArgParser {
 
         reforge ?: return null
 
-        ReforgeUtils.setReforge(meta, reforge)
+        meta.reforge = reforge
 
         return Predicate { test ->
             val testMeta = test.itemMeta ?: return@Predicate false
-            reforge == ReforgeUtils.getReforge(testMeta)
+            reforge == testMeta.reforge
         }
     }
 
     override fun serializeBack(meta: ItemMeta): String? {
-        val reforge = ReforgeUtils.getReforge(meta) ?: return null
+        val reforge = meta.reforge ?: return null
 
         return "reforge:${reforge.id}"
     }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/AntiPlaceListener.kt

@@ -7,7 +7,7 @@ import org.bukkit.event.block.BlockPlaceEvent
 class AntiPlaceListener : Listener {
     @EventHandler
     fun onBlockPlace(event: BlockPlaceEvent) {
-        if (ReforgeUtils.getReforgeStone(event.itemInHand) != null) {
+        if (event.itemInHand.reforgeStone != null) {
             event.isCancelled = true
             event.setBuild(false)
         }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/DiscoverRecipeListener.kt

@@ -2,29 +2,23 @@ package com.willfp.reforges.util
 
 import com.willfp.eco.core.EcoPlugin
 import org.bukkit.Bukkit
+import org.bukkit.Keyed
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
 import org.bukkit.event.player.PlayerJoinEvent
 import org.bukkit.inventory.Recipe
-import org.bukkit.inventory.ShapedRecipe
 
-class DiscoverRecipeListener(
+class DiscoverRecipeListener(private val plugin: EcoPlugin) : Listener {
-    private val plugin: EcoPlugin
-) : Listener {
     @EventHandler
     fun onJoin(event: PlayerJoinEvent) {
-        val player = event.player
+        if (!plugin.configYml.getBool("discover-recipes")) {
-        if (plugin.configYml.getBool("discover-recipes")) {
+            return
-            Bukkit.getServer().recipeIterator().forEachRemaining { recipe: Recipe ->
-                if (recipe is ShapedRecipe) {
-                    val key = recipe.key
-                    if (key.namespace == "reforges") {
-                        if (!key.key.contains("displayed")) {
-                            player.discoverRecipe(key)
-                        }
-                    }
-                }
-            }
         }
+        mutableListOf<Recipe>()
+            .apply { Bukkit.getServer().recipeIterator().forEachRemaining(this::add) }
+            .filterIsInstance<Keyed>().map { it.key }
+            .filter { it.namespace == plugin.name.lowercase() }
+            .filter { !it.key.contains("displayed") }
+            .forEach { event.player.discoverRecipe(it) }
     }
-}
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeLookup.kt

@@ -4,7 +4,6 @@ import com.github.benmanes.caffeine.cache.Caffeine
 import com.willfp.reforges.ReforgesPlugin
 import com.willfp.reforges.reforges.Reforge
 import com.willfp.reforges.reforges.ReforgeTarget
-import com.willfp.reforges.util.ReforgeUtils.getReforge
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
 import java.util.concurrent.TimeUnit
@@ -50,7 +49,7 @@ object ReforgeLookup {
             val found = mutableListOf<Reforge>()
 
             for ((itemStack, slot) in provide(player)) {
-                val reforge = getReforge(itemStack) ?: continue
+                val reforge = itemStack.reforge ?: continue
                 if (slot != ReforgeTarget.Slot.ANY) {
                     if (!reforge.targets.map { it.slot }.contains(slot)) {
                         continue
@@ -104,4 +103,4 @@ object ReforgeLookup {
             items
         }
     }
-}
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeUtils.kt

@@ -1,283 +1,119 @@
 package com.willfp.reforges.util
 
-import com.willfp.eco.core.fast.FastItemStack
+import com.willfp.eco.core.fast.fast
-import com.willfp.eco.core.items.TestableItem
 import com.willfp.reforges.ReforgesPlugin
 import com.willfp.reforges.reforges.Reforge
-import com.willfp.reforges.reforges.Reforges.getByKey
-import com.willfp.reforges.reforges.Reforges.values
 import com.willfp.reforges.reforges.ReforgeTarget
-import com.willfp.reforges.reforges.util.MetadatedReforgeStatus
+import com.willfp.reforges.reforges.Reforges
-import org.bukkit.Material
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.ItemMeta
 import org.bukkit.persistence.PersistentDataContainer
 import org.bukkit.persistence.PersistentDataType
 
-object ReforgeUtils {
+private val plugin = ReforgesPlugin.instance
-    private val PLUGIN = ReforgesPlugin.instance
+private val reforgeKey = plugin.namespacedKeyFactory.create("reforge")
+private val reforgeAmountKey = plugin.namespacedKeyFactory.create("reforge_amount")
+private val reforgeStoneKey = plugin.namespacedKeyFactory.create("reforge_stone")
 
-    /**
+var ItemStack?.reforge: Reforge?
-     * The key for storing reforges.
+    get() {
-     */
+        this ?: return null
-    private val REFORGE_KEY = PLUGIN.namespacedKeyFactory.create("reforge")
+        return this.fast().persistentDataContainer.reforge
-
+    }
-    /**
+    set(value) {
-     * The key for storing reforge amounts.
+        this ?: return
-     */
+        this.fast().persistentDataContainer.reforge = value
-    private val REFORGE_AMOUNT = PLUGIN.namespacedKeyFactory.create("reforge_amount")
-
-    /**
-     * The key for storing reforge stones.
-     */
-    private val REFORGE_STONE_KEY = PLUGIN.namespacedKeyFactory.create("reforge_stone")
-
-    /**
-     * Get a random reforge for a target.
-     *
-     * @param targets    The targets.
-     */
-    fun getRandomReforge(targets: Collection<ReforgeTarget>): Reforge? {
-        return getRandomReforge(targets, emptyList())
     }
 
-    /**
+var ItemMeta?.reforge: Reforge?
-     * Get a random reforge for a target.
+    get() {
-     *
+        this ?: return null
-     * @param targets    The targets.
+        return this.persistentDataContainer.reforge
-     * @param disallowed The disallowed reforges.
+    }
-     */
+    set(value) {
-    @JvmStatic
+        this ?: return
-    fun getRandomReforge(
+        this.persistentDataContainer.reforge = value
-        targets: Collection<ReforgeTarget>,
+    }
-        disallowed: Collection<Reforge>
+
-    ): Reforge? {
+var PersistentDataContainer?.reforge: Reforge?
-        val applicable = mutableListOf<Reforge>()
+    get() {
-        for (reforge in values()) {
+        this ?: return null
-            for (target in targets) {
+
-                if (reforge.targets.contains(target) && !reforge.requiresStone) {
+        if (!this.has(reforgeKey, PersistentDataType.STRING)) {
-                    applicable.add(reforge)
+            return null
-                }
-            }
         }
-        applicable.shuffle()
 
-        applicable.removeAll(disallowed)
+        val active = this.get(reforgeKey, PersistentDataType.STRING)
-        return if (applicable.isEmpty()) {
+        return Reforges.getByKey(active)
-            null
-        } else applicable[0]
     }
-
+    set(value) {
-    fun getStatus(captive: List<ItemStack?>): MetadatedReforgeStatus {
+        this ?: return
-        val toReforge = if (captive.isEmpty()) null else captive[0]
+        if (value == null) {
-        val stone = if (captive.size == 2) captive[1] else null
+            this.remove(reforgeKey)
-        var status: ReforgeStatus? = null
-        val target: MutableList<ReforgeTarget> = ArrayList()
-        if (toReforge == null || toReforge.type == Material.AIR) {
-            status = ReforgeStatus.NO_ITEM
         } else {
-            target.addAll(ReforgeTarget.getForItem(toReforge))
+            this.set(reforgeKey, PersistentDataType.STRING, value.id)
-            if (target.isEmpty()) {
+        }
-                status = ReforgeStatus.INVALID_ITEM
+    }
+
+var ItemStack?.reforgeStone: Reforge?
+    get() {
+        this ?: return null
+        return this.fast().persistentDataContainer.reforgeStone
+    }
+    set(value) {
+        this ?: return
+        this.fast().persistentDataContainer.reforgeStone = value
+    }
+
+var ItemMeta?.reforgeStone: Reforge?
+    get() {
+        this ?: return null
+        return this.persistentDataContainer.reforgeStone
+    }
+    set(value) {
+        this ?: return
+        this.persistentDataContainer.reforgeStone = value
+    }
+
+var PersistentDataContainer?.reforgeStone: Reforge?
+    get() {
+        this ?: return null
+
+        if (!this.has(reforgeStoneKey, PersistentDataType.STRING)) {
+            return null
+        }
+
+        val active = this.get(reforgeStoneKey, PersistentDataType.STRING)
+        return Reforges.getByKey(active)
+    }
+    set(value) {
+        this ?: return
+        if (value == null) {
+            this.remove(reforgeStoneKey)
+        } else {
+            this.set(reforgeStoneKey, PersistentDataType.STRING, value.id)
+        }
+    }
+
+var ItemStack.timesReforged: Int
+    get() = this.fast().persistentDataContainer.get(reforgeAmountKey, PersistentDataType.INTEGER) ?: 0
+    set(value) = this.fast().persistentDataContainer.set(reforgeAmountKey, PersistentDataType.INTEGER, value)
+
+fun Collection<ReforgeTarget>.getRandomReforge(
+    disallowed: Collection<Reforge> = emptyList()
+): Reforge? {
+    val applicable = mutableListOf<Reforge>()
+    for (reforge in Reforges.values()) {
+        for (target in this) {
+            if (reforge.targets.contains(target) && !reforge.requiresStone) {
+                applicable.add(reforge)
             }
         }
-        if (target.isNotEmpty()) {
-            status = ReforgeStatus.ALLOW
-        }
-        var cost = 0.0
-        if (status == ReforgeStatus.ALLOW) {
-            val reforgeStone = getReforgeStone(stone)
-            if (reforgeStone != null && reforgeStone.targets.stream()
-                    .anyMatch { reforgeTarget: ReforgeTarget ->
-                        reforgeTarget.items.stream()
-                            .anyMatch { item: TestableItem -> item.matches(toReforge) }
-                    }
-            ) {
-                cost = reforgeStone.stonePrice.toDouble()
-                status = ReforgeStatus.ALLOW_STONE
-            }
-        }
-        return MetadatedReforgeStatus(status!!, cost)
     }
+    applicable.shuffle()
 
-    /**
+    applicable.removeAll(disallowed)
-     * Get reforge on an item.
+    return if (applicable.isEmpty()) {
-     *
+        null
-     * @param item The item to query.
+    } else applicable[0]
-     * @return The found reforge, or null.
+}
-     */
-    fun getReforge(item: ItemStack?): Reforge? {
-        if (item == null) {
-            return null
-        }
-        val container = FastItemStack.wrap(item).persistentDataContainer
-        return getReforge(container)
-    }
-
-    /**
-     * Get reforge on an item.
-     *
-     * @param meta The item to query.
-     * @return The found reforge, or null.
-     */
-    fun getReforge(meta: ItemMeta?): Reforge? {
-        if (meta == null) {
-            return null
-        }
-        val container = meta.persistentDataContainer
-        if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) {
-            return null
-        }
-        val active = container.get(REFORGE_KEY, PersistentDataType.STRING)
-        return getByKey(active)
-    }
-
-    /**
-     * Get reforge on an item.
-     *
-     * @param container The item to query.
-     * @return The found reforge, or null.
-     */
-    fun getReforge(container: PersistentDataContainer?): Reforge? {
-        if (container == null) {
-            return null
-        }
-        if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) {
-            return null
-        }
-        val active = container.get(REFORGE_KEY, PersistentDataType.STRING)
-        return getByKey(active)
-    }
-
-    /**
-     * Set reforge on an item.
-     *
-     * @param item    The item.
-     * @param reforge The reforge.
-     */
-    fun setReforge(
-        item: ItemStack,
-        reforge: Reforge
-    ) {
-        if (item.itemMeta == null) {
-            return
-        }
-        val meta = item.itemMeta
-        setReforge(meta, reforge)
-        item.itemMeta = meta
-    }
-
-    /**
-     * Set reforge on an item.
-     *
-     * @param meta    The meta.
-     * @param reforge The reforge.
-     */
-    fun setReforge(
-        meta: ItemMeta,
-        reforge: Reforge
-    ) {
-        val container = meta.persistentDataContainer
-        container.set(REFORGE_KEY, PersistentDataType.STRING, reforge.id)
-    }
-
-    /**
-     * Get reforge stone on an item.
-     *
-     * @param item The item to query.
-     * @return The found reforge, or null.
-     */
-    fun getReforgeStone(item: ItemStack?): Reforge? {
-        if (item == null) {
-            return null
-        }
-        val container = FastItemStack.wrap(item).persistentDataContainer
-        return getReforgeStone(container)
-    }
-
-    /**
-     * Get reforge stone on an item.
-     *
-     * @param meta The item to query.
-     * @return The found reforge, or null.
-     */
-    fun getReforgeStone(meta: ItemMeta?): Reforge? {
-        if (meta == null) {
-            return null
-        }
-        val container = meta.persistentDataContainer
-        if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) {
-            return null
-        }
-        val active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING)
-        return getByKey(active)
-    }
-
-    /**
-     * Get reforge stone on an item.
-     *
-     * @param container The item to query.
-     * @return The found reforge, or null.
-     */
-    fun getReforgeStone(container: PersistentDataContainer?): Reforge? {
-        if (container == null) {
-            return null
-        }
-        if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) {
-            return null
-        }
-        val active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING)
-        return getByKey(active)
-    }
-
-    /**
-     * Set an item to be a reforge stone.
-     *
-     * @param item    The item.
-     * @param reforge The reforge.
-     */
-    fun setReforgeStone(
-        item: ItemStack,
-        reforge: Reforge
-    ) {
-        if (item.itemMeta == null) {
-            return
-        }
-        val meta = item.itemMeta
-        val container = meta.persistentDataContainer
-        container.set(REFORGE_STONE_KEY, PersistentDataType.STRING, reforge.id)
-        item.itemMeta = meta
-    }
-
-    /**
-     * Get the amount of reforges done to an item.
-     *
-     * @param item The item.
-     */
-    @JvmStatic
-    fun getReforges(item: ItemStack): Int {
-        val meta = item.itemMeta ?: return 0
-        val container = meta.persistentDataContainer
-        if (!container.has(REFORGE_AMOUNT, PersistentDataType.INTEGER)) {
-            container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, 0)
-            item.itemMeta = meta
-        }
-        val amount = container.get(REFORGE_AMOUNT, PersistentDataType.INTEGER)
-        return amount ?: 0
-    }
-
-    /**
-     * Get the amount of reforges done to an item.
-     *
-     * @param item The item.
-     */
-    @JvmStatic
-    fun incrementReforges(item: ItemStack) {
-        val meta = item.itemMeta ?: return
-        var amount = getReforges(item)
-        amount++
-        val container = meta.persistentDataContainer
-        container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, amount)
-        item.itemMeta = meta
-    }
-}