path: root/src/main/java/at/hannibal2/skyhanni/features/dungeon/DungeonFinderFeatures.kt

package at.hannibal2.skyhanni.features.dungeon

import at.hannibal2.skyhanni.SkyHanniMod
import at.hannibal2.skyhanni.config.ConfigUpdaterMigrator
import at.hannibal2.skyhanni.events.GuiContainerEvent
import at.hannibal2.skyhanni.events.InventoryCloseEvent
import at.hannibal2.skyhanni.events.InventoryOpenEvent
import at.hannibal2.skyhanni.events.LorenzToolTipEvent
import at.hannibal2.skyhanni.events.RenderInventoryItemTipEvent
import at.hannibal2.skyhanni.utils.ItemUtils.getLore
import at.hannibal2.skyhanni.utils.LorenzColor
import at.hannibal2.skyhanni.utils.LorenzUtils
import at.hannibal2.skyhanni.utils.NumberUtil.romanToDecimalIfNecessary
import at.hannibal2.skyhanni.utils.RegexUtils.anyMatches
import at.hannibal2.skyhanni.utils.RegexUtils.matchMatcher
import at.hannibal2.skyhanni.utils.RegexUtils.matches
import at.hannibal2.skyhanni.utils.RenderUtils.highlight
import at.hannibal2.skyhanni.utils.StringUtils.createCommaSeparatedList
import at.hannibal2.skyhanni.utils.StringUtils.removeColor
import at.hannibal2.skyhanni.utils.repopatterns.RepoPattern
import net.minecraft.item.ItemStack
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent

// TODO Remove all removeColor calls in this class. Deal with the color code in regex.
class DungeonFinderFeatures {
    private val config get() = SkyHanniMod.feature.dungeon.partyFinder

    //  Repo group and patterns
    private val patternGroup = RepoPattern.group("dungeon.finder")
    private val pricePattern by patternGroup.pattern(
        "price",
        "(?i).*([0-9]{2,3}K|[0-9]{1,3}M|[0-9]+\\.[0-9]M|[0-9] ?MIL).*"
    )
    private val carryPattern by patternGroup.pattern(
        "carry",
        "(?i).*(CARRY|CARY|CARRIES|CARIES|COMP|TO CATA [0-9]{2}).*"
    )
    private val nonPugPattern by patternGroup.pattern(
        "nonpug",
        "(?i).*(PERM|VC|DISCORD).*"
    )
    private val memberPattern by patternGroup.pattern(
        "member",
        ".*§.(?<playerName>.*)§f: §e(?<className>.*)§b \\(§e(?<level>.*)§b\\)"
    )
    private val ineligiblePattern by patternGroup.pattern(
        "ineligible",
        "§c(Requires .*$|You don't meet the requirement!|Complete previous floor first!$)"
    )
    private val classLevelPattern by patternGroup.pattern(
        "class.level",
        " §.(?<playerName>.*)§f: §e(?<className>.*)§b \\(§e(?<level>.*)§b\\)"
    )
    private val notePattern by patternGroup.pattern(
        "note",
        "§7§7Note: §f(?<note>.*)"
    )
    private val floorTypePattern by patternGroup.pattern(
        "floor.type",
        "(The Catacombs).*|.*(MM Catacombs).*"
    )
    private val checkIfPartyPattern by patternGroup.pattern(
        "check.if.party",
        ".*('s Party)"
    )
    private val partyFinderTitlePattern by patternGroup.pattern(
        "party.finder.title",
        "(Party Finder)"
    )
    private val catacombsGatePattern by patternGroup.pattern(
        "catacombs.gate",
        "(Catacombs Gate)"
    )
    private val selectFloorPattern by patternGroup.pattern(
        "select.floor",
        "(Select Floor)"
    )
    private val entranceFloorPattern by patternGroup.pattern(
        "entrance",
        "(.*Entrance)"
    )
    private val floorPattern by patternGroup.pattern(
        "floor",
        "(Floor .*)"
    )
    private val anyFloorPattern by patternGroup.pattern(
        "floor.any",
        "(Any)"
    )
    private val masterModeFloorPattern by patternGroup.pattern(
        "floor.mastermode",
        "(MM )|(.*Master Mode Catacombs)"
    )
    private val dungeonFloorPattern by patternGroup.pattern(
        "floor.dungeon",
        "(Dungeon: .*)"
    )
    private val floorFloorPattern by patternGroup.pattern(
        "floor.pattern",
        "(Floor: .*)"
    )
    private val floorNumberPattern by patternGroup.pattern(
        "floor.number",
        ".* (?<floorNum>[IV\\d]+)"
    )
    private val getDungeonClassPattern by patternGroup.pattern(
        "get.dungeon.class",
        ".* (?<class>.*)"
    )
    private val detectDungeonClassPattern by patternGroup.pattern(
        "detect.dungeon.class",
        "§7View and select a dungeon class."
    )

    private val allowedSlots = (10..34).filter { it !in listOf(17, 18, 26, 27) }

    //  Variables used
    private var selectedClass = ""
    private var floorStackSize = mapOf<Int, String>()
    private var highlightParty = mapOf<Int, LorenzColor>()
    private var toolTipMap = mapOf<Int, List<String>>()
    private var inInventory = false

    @SubscribeEvent
    fun onInventoryOpen(event: InventoryOpenEvent) {
        if (!isEnabled()) return

        floorStackSize = stackTip(event)
        highlightParty = highlightingHandler(event)
        toolTipMap = toolTipHandler(event)
    }

    private fun stackTip(event: InventoryOpenEvent): Map<Int, String> {
        val map = mutableMapOf<Int, String>()
        val inventoryName = event.inventoryName
        if (catacombsGatePattern.matches(inventoryName)) catacombsGateStackTip(event.inventoryItems, map)
        if (!config.floorAsStackSize) return map
        if (selectFloorPattern.matches(inventoryName)) selectFloorStackTip(event.inventoryItems, map)
        if (partyFinderTitlePattern.matches(inventoryName)) partyFinderStackTip(event.inventoryItems, map)
        return map
    }

    private fun selectFloorStackTip(inventoryItems: Map<Int, ItemStack>, map: MutableMap<Int, String>) {
        inInventory = true
        for ((slot, stack) in inventoryItems) {
            val name = stack.displayName.removeColor()
            map[slot] = if (anyFloorPattern.matches(name)) {
                "A"
            } else if (entranceFloorPattern.matches(name)) {
                "E"
            } else if (floorPattern.matches(name)) {
                floorNumberPattern.matchMatcher(name) {
                    group("floorNum").romanToDecimalIfNecessary().toString()
                } ?: continue
            } else continue
        }
    }

    private fun partyFinderStackTip(inventoryItems: Map<Int, ItemStack>, map: MutableMap<Int, String>) {
        inInventory = true
        for ((slot, stack) in inventoryItems) {
            val name = stack.displayName.removeColor()
            if (!checkIfPartyPattern.matches(name)) continue
            val lore = stack.getLore()
            val floor = lore.find { floorFloorPattern.matches(it.removeColor()) } ?: continue
            val dungeon = lore.find { dungeonFloorPattern.matches(it.removeColor()) } ?: continue
            val floorNum = floorNumberPattern.matchMatcher(floor) {
                group("floorNum").romanToDecimalIfNecessary()
            }
            map[slot] = getFloorName(floor, dungeon, floorNum)
        }
    }

    private fun catacombsGateStackTip(inventoryItems: Map<Int, ItemStack>, map: MutableMap<Int, String>) {
        val dungeonClassItemIndex = 45
        inInventory = true
        inventoryItems[dungeonClassItemIndex]?.getLore()?.let {
            if (it.size > 3 && detectDungeonClassPattern.matches(it[0])) {
                getDungeonClassPattern.matchMatcher(it[2].removeColor()) {
                    selectedClass = group("class")
                }
            }
        }

        if (!config.floorAsStackSize) return
        for ((slot, stack) in inventoryItems) {
            val name = stack.displayName.removeColor()
            if (!floorTypePattern.matches(name)) continue
            val floorNum = floorNumberPattern.matchMatcher(name) {
                group("floorNum").romanToDecimalIfNecessary()
            } ?: continue
            map[slot] = getFloorName(name, name, floorNum)
        }
    }

    private fun getFloorName(floor: String, dungeon: String, floorNum: Int?): String =
        if (entranceFloorPattern.matches(floor)) {
            "E"
        } else if (masterModeFloorPattern.matches(dungeon)) {
            "M$floorNum"
        } else {
            "F$floorNum"
        }

    private fun highlightingHandler(event: InventoryOpenEvent): Map<Int, LorenzColor> {
        val</