Feature: Corpse Tracker (#2306)

13 files changed, 513 insertions, 5 deletions

diff --git a/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt b/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt
index edfdb2d7a..7a17c1462 100644
--- a/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt
+++ b/src/main/java/at/hannibal2/skyhanni/config/commands/Commands.kt
@@ -58,6 +58,7 @@ import at.hannibal2.skyhanni.features.garden.visitor.GardenVisitorDropStatistics
 import at.hannibal2.skyhanni.features.inventory.chocolatefactory.ChocolateFactoryStrayTracker
 import at.hannibal2.skyhanni.features.mining.KingTalismanHelper
 import at.hannibal2.skyhanni.features.mining.MineshaftPityDisplay
+import at.hannibal2.skyhanni.features.mining.glacitemineshaft.CorpseTracker
 import at.hannibal2.skyhanni.features.mining.fossilexcavator.ExcavatorProfitTracker
 import at.hannibal2.skyhanni.features.mining.powdertracker.PowderTracker
 import at.hannibal2.skyhanni.features.minion.MinionFeatures
@@ -219,6 +220,7 @@ object Commands {
         registerCommand("shresetghostcounter", "Resets the ghost counter") { GhostUtil.reset() }
         registerCommand("shresetpowdertracker", "Resets the Powder Tracker") { PowderTracker.resetCommand() }
         registerCommand("shresetdicertracker", "Resets the Dicer Drop Tracker") { DicerRngDropTracker.resetCommand() }
+        registerCommand("shresetcorpsetracker", "Resets the Glacite Mineshaft Corpse Tracker") { CorpseTracker.resetCommand() }
         registerCommand(
             "shresetendernodetracker",
             "Resets the Ender Node Tracker",
diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/mining/CorpseTrackerConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/mining/CorpseTrackerConfig.java
new file mode 100644
index 000000000..61d3b1959
--- /dev/null
+++ b/src/main/java/at/hannibal2/skyhanni/config/features/mining/CorpseTrackerConfig.java
@@ -0,0 +1,24 @@
+package at.hannibal2.skyhanni.config.features.mining;
+
+import at.hannibal2.skyhanni.config.core.config.Position;
+import com.google.gson.annotations.Expose;
+import io.github.notenoughupdates.moulconfig.annotations.ConfigEditorBoolean;
+import io.github.notenoughupdates.moulconfig.annotations.ConfigLink;
+import io.github.notenoughupdates.moulconfig.annotations.ConfigOption;
+
+public class CorpseTrackerConfig {
+
+    @Expose
+    @ConfigOption(name = "Enabled", desc = "Enable the Corpse Tracker overlay for Glacite Mineshafts.")
+    @ConfigEditorBoolean
+    public boolean enabled = false;
+
+    @Expose
+    @ConfigOption(name = "Only when in Mineshaft", desc = "Only show the overlay while in a Glacite Mineshaft.")
+    @ConfigEditorBoolean
+    public boolean onlyInMineshaft = false;
+
+    @Expose
+    @ConfigLink(owner = CorpseTrackerConfig.class, field = "enabled")
+    public Position position = new Position(-274, 0, false, true);
+}
diff --git a/src/main/java/at/hannibal2/skyhanni/config/features/mining/GlaciteMineshaftConfig.java b/src/main/java/at/hannibal2/skyhanni/config/features/mining/GlaciteMineshaftConfig.java
index b89a7d3d0..723cf9b90 100644
--- a/src/main/java/at/hannibal2/skyhanni/config/features/mining/GlaciteMineshaftConfig.java
+++ b/src/main/java/at/hannibal2/skyhanni/config/features/mining/GlaciteMineshaftConfig.java
@@ -18,6 +18,11 @@ public class GlaciteMineshaftConfig {
     public CorpseLocatorConfig corpseLocator = new CorpseLocatorConfig();
 
     @Expose
+    @ConfigOption(name = "Corpse Tracker", desc = "")
+    @Accordion
+    public CorpseTrackerConfig corpseTracker = new CorpseTrackerConfig();
+
+    @Expose
     @ConfigOption(name = "Share Waypoint Location", desc = "Share the location of the nearest waypoint upon key press.\n" +
         "§eYou can share the location even if it has already been shared!")
     @ConfigEditorKeybind(defaultKey = Keyboard.KEY_NONE)
diff --git a/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java b/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java
index d622d317a..5938eebdb 100644
--- a/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java
+++ b/src/main/java/at/hannibal2/skyhanni/config/storage/ProfileSpecificStorage.java
@@ -33,6 +33,7 @@ import at.hannibal2.skyhanni.features.inventory.chocolatefactory.ChocolateFactor
 import at.hannibal2.skyhanni.features.inventory.wardrobe.WardrobeAPI;
 import at.hannibal2.skyhanni.features.mining.MineshaftPityDisplay;
 import at.hannibal2.skyhanni.features.mining.fossilexcavator.ExcavatorProfitTracker;
+import at.hannibal2.skyhanni.features.mining.glacitemineshaft.CorpseTracker;
 import at.hannibal2.skyhanni.features.mining.powdertracker.PowderTracker;
 import at.hannibal2.skyhanni.features.misc.trevor.TrevorTracker;
 import at.hannibal2.skyhanni.features.rift.area.westvillage.VerminTracker;
@@ -564,6 +565,9 @@ public class ProfileSpecificStorage {
 
             @Expose
             public List<MineshaftPityDisplay.PityData> blocksBroken = new ArrayList<>();
+
+            @Expose
+            public CorpseTracker.BucketData corpseProfitTracker = new CorpseTracker.BucketData();
         }
     }
 
diff --git a/src/main/java/at/hannibal2/skyhanni/events/mining/CorpseLootedEvent.kt b/src/main/java/at/hannibal2/skyhanni/events/mining/CorpseLootedEvent.kt
index ea1e813d0..9e38d8e95 100644
--- a/src/main/java/at/hannibal2/skyhanni/events/mining/CorpseLootedEvent.kt
+++ b/src/main/java/at/hannibal2/skyhanni/events/mining/CorpseLootedEvent.kt
@@ -1,6 +1,6 @@
 package at.hannibal2.skyhanni.events.mining
 
 import at.hannibal2.skyhanni.events.LorenzEvent
-import at.hannibal2.skyhanni.features.mining.mineshaft.CorpseType
+import at.hannibal2.skyhanni.features.mining.glacitemineshaft.CorpseType
 
 class CorpseLootedEvent(val corpseType: CorpseType, val loot: List<Pair<String, Int>>) : LorenzEvent()
diff --git a/src/main/java/at/hannibal2/skyhanni/features/mining/mineshaft/CorpseAPI.kt b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/CorpseAPI.kt
index e49ca462f..c8ee81288 100644
--- a/src/main/java/at/hannibal2/skyhanni/features/mining/mineshaft/CorpseAPI.kt
+++ b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/CorpseAPI.kt
@@ -1,4 +1,4 @@
-package at.hannibal2.skyhanni.features.mining.mineshaft
+package at.hannibal2.skyhanni.features.mining.glacitemineshaft
 
 import at.hannibal2.skyhanni.data.IslandType
 import at.hannibal2.skyhanni.events.LorenzChatEvent
diff --git a/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/CorpseTracker.kt b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/CorpseTracker.kt
new file mode 100644
index 000000000..77aabc1bd
--- /dev/null
+++ b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/CorpseTracker.kt
@@ -0,0 +1,142 @@
+package at.hannibal2.skyhanni.features.mining.glacitemineshaft
+
+import at.hannibal2.skyhanni.SkyHanniMod
+import at.hannibal2.skyhanni.data.IslandType
+import at.hannibal2.skyhanni.events.GuiRenderEvent
+import at.hannibal2.skyhanni.events.IslandChangeEvent
+import at.hannibal2.skyhanni.events.mining.CorpseLootedEvent
+import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule
+import at.hannibal2.skyhanni.utils.CollectionUtils.addOrPut
+import at.hannibal2.skyhanni.utils.CollectionUtils.addSearchString
+import at.hannibal2.skyhanni.utils.CollectionUtils.sumAllValues
+import at.hannibal2.skyhanni.utils.ItemPriceUtils.getPrice
+import at.hannibal2.skyhanni.utils.ItemUtils.itemName
+import at.hannibal2.skyhanni.utils.LorenzUtils
+import at.hannibal2.skyhanni.utils.LorenzUtils.isInIsland
+import at.hannibal2.skyhanni.utils.NEUInternalName
+import at.hannibal2.skyhanni.utils.NumberUtil.addSeparators
+import at.hannibal2.skyhanni.utils.NumberUtil.shortFormat
+import at.hannibal2.skyhanni.utils.renderables.Renderable
+import at.hannibal2.skyhanni.utils.renderables.Searchable
+import at.hannibal2.skyhanni.utils.renderables.toSearchable
+import at.hannibal2.skyhanni.utils.tracker.BucketedItemTrackerData
+import at.hannibal2.skyhanni.utils.tracker.ItemTrackerData.TrackedItem
+import at.hannibal2.skyhanni.utils.tracker.SkyHanniBucketedItemTracker
+import com.google.gson.annotations.Expose
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+import java.util.EnumMap
+
+@SkyHanniModule
+object CorpseTracker {
+    private val config get() = SkyHanniMod.feature.mining.glaciteMineshaft.corpseTracker
+
+    private val tracker = SkyHanniBucketedItemTracker<CorpseType, BucketData>(
+        "Corpse Tracker",
+        { BucketData() },
+        { it.mining.mineshaft.corpseProfitTracker },
+        { drawDisplay(it) }
+    )
+
+    class BucketData : BucketedItemTrackerData<CorpseType>() {
+        override fun resetItems() {
+            corpsesLooted = EnumMap(CorpseType::class.java)
+        }
+
+        override fun getDescription(timesGained: Long): List<String> {
+            val divisor = 1.coerceAtLeast(getSelectedBucket()?.let { corpsesLooted[it]?.toInt() } ?: corpsesLooted.sumAllValues().toInt())
+            val percentage = timesGained.toDouble() / divisor
+            val dropRate = LorenzUtils.formatPercentage(percentage.coerceAtMost(1.0))
+            return listOf(
+                "§7Dropped §e${timesGained.addSeparators()} §7times.",
+                "§7Your drop rate: §c$dropRate.",
+            )
+        }
+
+        override fun getCoinName(bucket: CorpseType?, item: TrackedItem) = "<no coins>"
+        override fun getCoinDescription(bucket: CorpseType?, item: TrackedItem): List<String> = listOf("<no coins>")
+
+        @Expose
+        var corpsesLooted: MutableMap<CorpseType, Long> = EnumMap(CorpseType::class.java)
+
+        fun getCorpseCount(): Long = getSelectedBucket()?.let { corpsesLooted[it] } ?: corpsesLooted.values.sum()
+    }
+
+    private fun addLootedCorpse(type: CorpseType) = tracker.modify { it.corpsesLooted.addOrPut(type, 1) }
+
+    @SubscribeEvent
+    fun onCorpseLoot(event: CorpseLootedEvent) {
+        addLootedCorpse(event.corpseType)
+        for ((itemName, amount) in event.loot) {
+            NEUInternalName.fromItemNameOrNull(itemName)?.let { item ->
+                tracker.modify {
+                    it.addItem(event.corpseType, item, amount)
+                }
+            }
+        }
+    }
+
+    private fun drawDisplay(bucketData: BucketData): List<Searchable> = buildList {
+        addSearchString("§b§lMineshaft Corpse Profit Tracker")
+        tracker.addBucketSelector(this, bucketData, "Corpse Type")
+
+        if (bucketData.getCorpseCount() == 0L) return@buildList
+
+        var profit = tracker.drawItems(bucketData, { true }, this)
+        val applicableKeys: List<CorpseType> = bucketData.getSelectedBucket()?.let { listOf(it) }
+            ?: enumValues<CorpseType>().toList().filter { bucketData.corpsesLooted[it] != null }
+        var totalKeyCost = 0.0
+        var totalKeyCount = 0
+        val keyCostStrings = buildList {
+            applicableKeys.forEach { keyData ->
+                keyData.key?.let { key ->
+                    val keyName = key.itemName
+                    val price = key.getPrice()
+                    val count = bucketData.corpsesLooted[keyData] ?: 0
+                    val totalPrice = price * count
+                    if (totalPrice > 0) {
+                        profit -= totalPrice
+                        totalKeyCost += totalPrice
+                        totalKeyCount += count.toInt()
+                        add("§7${count}x $keyName§7: §c-${totalPrice.shortFormat()}")
+                    }
+                }
+            }
+        }
+
+        if (totalKeyCount > 0) {
+            val specificKeyFormat = if (applicableKeys.count() == 1) applicableKeys.first().key!!.itemName else "§eCorpse Keys"
+            val keyFormat = "§7${totalKeyCount}x $specificKeyFormat§7: §c-${totalKeyCost.shortFormat()}"
+            add(
+                if (applicableKeys.count() == 1) Renderable.string(keyFormat).toSearchable()
+                else Renderable.hoverTips(
+                    keyFormat,
+                    keyCostStrings,
+                ).toSearchable(),
+            )
+        }
+
+        add(tracker.addTotalProfit(profit, bucketData.getCorpseCount(), "loot"))
+
+        tracker.addPriceFromButton(this)
+    }
+
+    @SubscribeEvent
+    fun onRenderOverlay(event: GuiRenderEvent) {
+        if (!isEnabled()) return
+        tracker.renderDisplay(config.position)
+    }
+
+    @SubscribeEvent
+    fun onIslandChange(event: IslandChangeEvent) {
+        if (event.newIsland == IslandType.MINESHAFT || event.newIsland == IslandType.DWARVEN_MINES) {
+            tracker.firstUpdate()
+        }
+    }
+
+    fun resetCommand() {
+        tracker.resetCommand()
+    }
+
+    fun isEnabled() =
+        config.enabled && IslandType.DWARVEN_MINES.isInIsland() && (!config.onlyInMineshaft || IslandType.MINESHAFT.isInIsland())
+}
diff --git a/src/main/java/at/hannibal2/skyhanni/features/mining/mineshaft/CorpseType.kt b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/CorpseType.kt
index 7ddfca867..42567d5f3 100644
--- a/src/main/java/at/hannibal2/skyhanni/features/mining/mineshaft/CorpseType.kt
+++ b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/CorpseType.kt
@@ -1,4 +1,4 @@
-package at.hannibal2.skyhanni.features.mining.mineshaft
+package at.hannibal2.skyhanni.features.mining.glacitemineshaft
 
 import at.hannibal2.skyhanni.utils.NEUInternalName.Companion.asInternalName
 
@@ -10,4 +10,6 @@ enum class CorpseType(val displayName: String, private val keyName: String? = nu
     ;
 
     val key by lazy { keyName?.asInternalName() }
+
+    override fun toString(): String = displayName
 }
diff --git a/src/main/java/at/hannibal2/skyhanni/features/mining/mineshaft/MineshaftCorpseProfitPer.kt b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/MineshaftCorpseProfitPer.kt
index 102391b87..eed5f2b9d 100644
--- a/src/main/java/at/hannibal2/skyhanni/features/mining/mineshaft/MineshaftCorpseProfitPer.kt
+++ b/src/main/java/at/hannibal2/skyhanni/features/mining/glacitemineshaft/MineshaftCorpseProfitPer.kt
@@ -1,4 +1,4 @@
-package at.hannibal2.skyhanni.features.mining.mineshaft
+package at.hannibal2.skyhanni.features.mining.glacitemineshaft
 
 import at.hannibal2.skyhanni.SkyHanniMod
 import at.hannibal2.skyhanni.events.mining.CorpseLootedEvent
diff --git a/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt
index 991b1a53e..898466ce4 100644
--- a/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt
+++ b/src/main/java/at/hannibal2/skyhanni/utils/CollectionUtils.kt
@@ -336,7 +336,7 @@ object CollectionUtils {
         for (entry in universe) {
             val display = getName(entry)
             if (isCurrent(entry)) {
-                addString("§a[$display]")
+                addString("§a[$display§a]")
             } else {
                 addString("§e[")
                 add(
diff --git a/src/main/java/at/hannibal2/skyhanni/utils/tracker/BucketedItemTrackerData.kt b/src/main/java/at/hannibal2/skyhanni/utils/tracker/BucketedItemTrackerData.kt
new file mode 100644
index 000000000..3bedaf8a4
--- /dev/null
+++ b/src/main/java/at/hannibal2/skyhanni/utils/tracker/BucketedItemTrackerData.kt
@@ -0,0 +1,101 @@
+package at.hannibal2.skyhanni.utils.tracker
+
+import at.hannibal2.skyhanni.SkyHanniMod
+import at.hannibal2.skyhanni.test.command.ErrorManager
+import at.hannibal2.skyhanni.utils.NEUInternalName
+import at.hannibal2.skyhanni.utils.SimpleTimeMark
+import at.hannibal2.skyhanni.utils.tracker.ItemTrackerData.TrackedItem
+import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
+
+abstract class BucketedItemTrackerData<E : Enum<E>> : TrackerData() {
+
+    private val config get() = SkyHanniMod.feature.misc.tracker
+
+    abstract fun resetItems()
+
+    abstract fun getDescription(timesGained: Long): List<String>
+
+    abstract fun getCoinName(bucket: E?, item: TrackedItem): String
+
+    abstract fun getCoinDescription(bucket: E?, item: TrackedItem): List<String>
+
+    open fun getCustomPricePer(internalName: NEUInternalName) = SkyHanniTracker.getPricePer(internalName)
+
+    override fun reset() {
+        bucketedItems.clear()
+        selectedBucket = null
+        resetItems()
+    }
+
+    fun addItem(bucket: E, internalName: NEUInternalName, stackSize: Int) {
+        val bucketMap = bucketedItems.getOrPut(bucket) { HashMap() }
+        val item = bucketMap.getOrPut(internalName) { TrackedItem() }
+
+        item.timesGained++
+        item.totalAmount += stackSize
+        item.lastTimeUpdated = SimpleTimeMark.now()
+    }
+
+    fun removeItem(bucket: E?, internalName: NEUInternalName) {
+        bucket?.let {
+            bucketedItems[bucket]?.remove(internalName)
+        } ?: bucketedItems.forEach {
+            it.value.remove(internalName)
+        }
+    }
+
+    fun toggleItemHide(bucket: E?, internalName: NEUInternalName) {
+        bucket?.let {
+            bucketedItems[bucket]?.get(internalName)?.let { it.hidden = !it.hidden }
+        } ?: bucketedItems.forEach {
+            it.value[internalName]?.hidden = !it.value[internalName]?.hidden!!
+        }
+    }
+
+    private val buckets: Array<E> by lazy {
+        @Suppress("UNCHECKED_CAST")
+        selectedBucket?.javaClass?.enumConstants
+            ?: (this.javaClass.genericSuperclass as? ParameterizedTypeImpl)?.actualTypeArguments?.firstOrNull()?.let { type ->
+                (type as? Class<E>)?.enumConstants
+            } ?: ErrorManager.skyHanniError(
+                "Unable to retrieve enum constants for E in BucketedItemTrackerData",
+                "selectedBucket" to selectedBucket,
+                "dataClass" to this.javaClass.superclass.name,
+            )
+    }
+
+    private var selectedBucket: E? = null
+    private var bucketedItems: MutableMap<E, MutableMap<NEUInternalName, TrackedItem>> = HashMap()
+
+    private fun getBucket(bucket: E): MutableMap<NEUInternalName, TrackedItem> = bucketedItems[bucket]?.toMutableMap() ?: HashMap()
+    private fun getPoppedBuckets(): MutableList<E> = (bucketedItems.toMutableMap().filter { it.value.isNotEmpty() }.keys).toMutableList()
+    fun getItemsProp(): MutableMap<NEUInternalName, TrackedItem> = getSelectedBucket()?.let { getBucket(it) } ?: flattenBuckets()
+    fun getSelectedBucket() = selectedBucket
+    fun selectNextSequentialBucket() {
+        // Move to the next ordinal, or wrap to null if at the last value
+        val nextOrdinal = selectedBucket?.let { it.ordinal + 1 } // Only calculate if selectedBucket is non-null
+        selectedBucket = when {
+            selectedBucket == null -> buckets.first() // If selectedBucket is null, start with the first enum
+            nextOrdinal != null && nextOrdinal >= buckets.size -> null // Wrap to null if we've reached the end
+            nextOrdinal != null -> buckets[nextOrdinal] // Move to the next enum value
+            else -> selectedBucket // Fallback, shouldn't happen
+        }
+    }
+
+    private fun flattenBuckets(): MutableMap<NEUInternalName, TrackedItem> {
+        val flatMap: MutableMap<NEUInternalName, TrackedItem> = HashMap()
+        getPoppedBuckets().distinct().forEach { bucket ->
+            getBucket(bucket).filter { !it.value.hidden }.entries.distinctBy { it.key }.forEach { (key, value) ->
+                flatMap.merge(key, value) { existing, new ->
+                    existing.copy(
+                        hidden = false,
+                        totalAmount = existing.totalAmount + new.totalAmount,
+                        timesGained = existing.timesGained + new.timesGained,
+                        lastTimeUpdated = maxOf(existing.lastTimeUpdated, new.lastTimeUpdated),
+                    )
+                }
+            }
+        }
+        return flatMap.toMutableMap()
+    }
+}
diff --git a/src/main/java/at/hannibal2/skyhanni/utils/tracker/ItemTrackerData.kt b/src/main/java/at/hannibal2/skyhanni/utils/tracker/ItemTrackerData.kt
index bce63e2d1..a3976e44f 100644
--- a/src/main/java/at/hannibal2/skyhanni/utils/tracker/ItemTrackerData.kt
+++ b/src/main/java/at/hannibal2/skyhanni/utils/tracker/ItemTrackerData.kt
@@ -52,5 +52,19 @@ abstract class ItemTrackerData : TrackerData() {
         var hidden = false
 
         var lastTimeUpdated = SimpleTimeMark.farPast()
+
+        fun copy(
+            timesGained: Long = this.timesGained,
+            totalAmount: Long = this.totalAmount,
+            hidden: Boolean = this.hidden,
+            lastTimeUpdated: SimpleTimeMark = this.lastTimeUpdated,
+        ): TrackedItem {
+            val copy = TrackedItem()
+            copy.timesGained = timesGained
+            copy.totalAmount = totalAmount
+            copy.hidden = hidden
+            copy.lastTimeUpdated = lastTimeUpdated
+            return copy
+        }
     }
 }
diff --git a/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniBucketedItemTracker.kt b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniBucketedItemTracker.kt
new file mode 100644
index 000000000..dcbab2b1b
--- /dev/null
+++ b/src/main/java/at/hannibal2/skyhanni/utils/tracker/SkyHanniBucketedItemTracker.kt
@@ -0,0 +1,214 @@
+package at.hannibal2.skyhanni.utils.tracker
+
+import at.hannibal2.skyhanni.SkyHanniMod
+import at.hannibal2.skyhanni.config.storage.ProfileSpecificStorage
+import at.hannibal2.skyhanni.data.SlayerAPI
+import at.hannibal2.skyhanni.utils.ChatUtils
+import at.hannibal2.skyhanni.utils.CollectionUtils.addSearchableSelector
+import at.hannibal2.skyhanni.utils.CollectionUtils.sortedDesc
+import at.hannibal2.skyhanni.utils.ItemPriceSource
+import at.hannibal2.skyhanni.utils.ItemUtils.itemName
+import at.hannibal2.skyhanni.utils.KeyboardManager
+import at.hannibal2.skyhanni.utils.LorenzUtils
+import at.hannibal2.skyhanni.utils.NEUInternalName
+import at.hannibal2.skyhanni.utils.NumberUtil.addSeparators
+import at.hannibal2.skyhanni.utils.NumberUtil.shortFormat
+import at.hannibal2.skyhanni.utils.StringUtils.removeColor
+import at.hannibal2.skyhanni.utils.renderables.Renderable
+import at.hannibal2.skyhanni.utils.renderables.RenderableUtils.addButton
+import at.hannibal2.skyhanni.utils.renderables.Searchable
+import at.hannibal2.skyhanni.utils.renderables.toSearchable
+import kotlin.time.Duration.Companion.seconds
+
+class SkyHanniBucketedItemTracker<E : Enum<E>, BucketedData : BucketedItemTrackerData<E>>(
+    name: String,
+    createNewSession: () -> BucketedData,
+    getStorage: (ProfileSpecificStorage) -> BucketedData,
+    drawDisplay: (BucketedData) -> List<Searchable>,
+    vararg extraStorage: Pair<DisplayMode, (ProfileSpecificStorage) -> BucketedData>,
+) : SkyHanniTracker<BucketedData>(name, createNewSession, getStorage, *extraStorage, drawDisplay = drawDisplay) {
+
+    companion object {
+        val SKYBLOCK_COIN = NEUInternalName.SKYBLOCK_COIN
+    }
+
+    fun addCoins(bucket: E, coins: Int) {
+        addItem(bucket, SKYBLOCK_COIN, coins)
+    }
+
+    fun addItem(bucket: E, internalName: NEUInternalName, amount: Int) {
+        modify {
+            it.addItem(bucket, internalName, amount)
+        }
+        getSharedTracker()?.let {
+            val hidden = it.get(DisplayMode.TOTAL).getItemsProp()[internalName]!!.hidden
+            it.get(DisplayMode.SESSION).getItemsProp()[internalName]!!.hidden = hidden
+        }
+
+        val (itemName, price) = SlayerAPI.getItemNameAndPrice(internalName, amount)
+        if (config.warnings.chat && price >= config.warnings.minimumChat) {
+            ChatUtils.chat("§a+Tracker Drop§7: §r$itemName")
+        }
+        if (config.warnings.title && price >= config.warnings.minimumTitle) {
+            LorenzUtils.sendTitle("§a+ $itemName", 5.seconds)
+        }
+    }
+
+    fun addPriceFromButton(lists: MutableList<Searchable>) {
+        if (isInventoryOpen()) {
+            lists.addSearchableSelector<ItemPriceSource>(
+                "",
+                getName = { type -> type.sellName },
+                isCurrent = { it?.ordinal == config.priceSource.ordinal }, // todo avoid ordinal
+                onChange = {
+                    config.priceSource = it?.let { ItemPriceSource.entries[it.ordinal] } // todo avoid ordinal
+                    update()
+                },
+            )
+        }
+    }
+
+    fun addBucketSelector(
+        lists: MutableList<Searchable>,
+        data: BucketedData,
+        sourceStringPrefix: String,
+        nullBucketLabel: String = "All",
+    ) {
+        if (isInventoryOpen()) {
+            lists.addButton(
+                prefix = "§7$sourceStringPrefix: ",
+                getName = data.getSelectedBucket()?.toString() ?: nullBucketLabel,
+                onChange = {
+                    data.selectNextSequentialBucket()
+                    update()
+                },
+            )
+        }
+    }
+
+    fun drawItems(
+        data: BucketedData,
+        filter: (NEUInternalName) -> Boolean,
+        lists: MutableList<Searchable>,
+    ): Double {
+        var profit = 0.0
+        val dataItems = data.getItemsProp()
+        val items = mutableMapOf<NEUInternalName, Long>()
+        for ((internalName, itemProfit) in dataItems) {
+            if (!filter(internalName)) continue
+
+            val amount = itemProfit.totalAmount
+            val pricePer =
+                if (internalName == SKYBLOCK_COIN) 1.0 else data.getCustomPricePer(internalName)
+            val price = (pricePer * amount).toLong()
+            val hidden = itemProfit.hidden
+
+            if (isInventoryOpen() || !hidden) {
+                items[internalName] = price
+            }
+            if (!hidden || !config.excludeHiddenItemsInPrice) {
+                profit += price
+            }
+        }
+
+        val limitList = config.hideCheapItems
+        var pos = 0
+        val hiddenItemTexts = mutableListOf<String>()
+        for ((internalName, price) in items.sortedDesc()) {
+            val itemProfit = data.getItemsProp()[internalName] ?: error("Item not found for $internalName")
+
+            val amount = itemProfit.totalAmount
+            val displayAmount = if (internalName == SKYBLOCK_COIN) itemProfit.timesGained else amount
+
+            val cleanName = if (internalName == SKYBLOCK_COIN) {
+                data.getCoinName(data.getSelectedBucket(), itemProfit)
+            } else {
+                internalName.itemName
+            }
+
+            val priceFormat = price.shortFormat()
+            val hidden = itemProfit.hidden
+            val newDrop = itemProfit.lastTimeUpdated.passedSince() < 10.seconds && config.showRecentDrops
+            val numberColor = if (newDrop) "§a§l" else "§7"
+
+            var displayName = if (hidden) {
+                "§8§m" + cleanName.removeColor(keepFormatting = true).replace("§r", "")
+            } else cleanName
+            displayName = " $numberColor${displayAmount.addSeparators()}x $displayName§7: §6$priceFormat"
+
+            pos++
+            if (limitList.enabled.get()) {
+                if (pos > limitList.alwaysShowBest.get()) {
+                    if (price < limitList.minPrice.get() * 1000) {
+                        hiddenItemTexts += displayName
+                        continue
+                    }
+                }
+            }
+
+            val lore = buildLore(data, itemProfit, hidden, newDrop, internalName)
+            val renderable = if (isInventoryOpen()) Renderable.clickAndHover(
+                displayName, lore,
+                onClick = {
+                    if (KeyboardManager.isModifierKeyDown()) {
+                        data.removeItem(data.getSelectedBucket(), internalName)
+                        ChatUtils.chat("Removed $cleanName §efrom $name${if (data.getSelectedBucket() != null) " (${data.getSelectedBucket()})" else ""}")
+                    } else {
+                        modify {
+                            it.toggleItemHide(data.getSelectedBucket(), internalName)
+                        }
+                    }
+                    update()
+
+                },
+            ) else Renderable.string(displayName)
+
+            lists.add(renderable.toSearchable(name))
+        }
+        if (hiddenItemTexts.size > 0) {
+            val text = Renderable.hoverTips(" §7${hiddenItemTexts.size} cheap items are hidden.", hiddenItemTexts).toSearchable()
+            lists.add(text)
+        }
+
+        return profit
+    }
+
+    private fun buildLore(
+        data: BucketedData,
+        item: ItemTrackerData.TrackedItem,
+        hidden: Boolean,
+        newDrop: Boolean,
+        internalName: NEUInternalName,
+    ) = buildList {
+        if (internalName == SKYBLOCK_COIN) {
+            addAll(data.getCoinDescription(data.getSelectedBucket(), item))
+        } else {
+            addAll(data.getDescription(item.timesGained))
+        }
+        add("")
+        if (newDrop) {
+            add("§aYou obtained this item recently.")
+            add("")
+        }
+        add("§eClick to " + (if (hidden) "show" else "hide") + "!")
+        add("§eControl + Click to remove this item!")
+        if (SkyHanniMod.feature.dev.debug.enabled) {
+            add("")
+            add("§7${internalName}")
+        }
+    }
+
+    fun addTotalProfit(profit: Double, totalAmount: Long, action: String): Searchable {
+        val profitFormat = profit.toLong().addSeparators()
+        val profitPrefix = if (profit < 0) "§c" else "§6"
+
+        val tips = if (totalAmount > 0) {
+            val profitPerCatch = profit / totalAmount
+            val profitPerCatchFormat = profitPerCatch.shortFormat()
+            listOf("§7Profit per $action: $profitPrefix$profitPerCatchFormat")
+        } else emptyList()
+
+        val text = "§eTotal Profit: $profitPrefix$profitFormat coins"
+        return Renderable.hoverTips(text, tips).toSearchable()
+    }
+}