VoidPlugin/VoidOp/src/main/kotlin/nl/voidcorp/opplugin/VoidOp.kt

package nl.voidcorp.opplugin

import com.destroystokyo.paper.event.block.BeaconEffectEvent
import nl.voidcorp.mainplugin.VoidPluginBase
import org.bukkit.Bukkit
import org.bukkit.Material
import org.bukkit.NamespacedKey
import org.bukkit.attribute.Attribute
import org.bukkit.attribute.AttributeModifier
import org.bukkit.block.Beacon
import org.bukkit.enchantments.Enchantment
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.Listener
import org.bukkit.event.block.BlockPlaceEvent
import org.bukkit.event.inventory.CraftItemEvent
import org.bukkit.event.player.PlayerAttemptPickupItemEvent
import org.bukkit.event.player.PlayerInteractEvent
import org.bukkit.inventory.*
import org.jetbrains.exposed.sql.SchemaUtils
import org.jetbrains.exposed.sql.transactions.transaction

class VoidOp(override val comment: String = "Make everyone very op...") : VoidPluginBase() {

    val maxistar = ItemStack(Material.NETHER_STAR).apply {
        amount = 1
        addUnsafeEnchantment(Enchantment.ARROW_INFINITE, 1)
        val meta = itemMeta
        meta.setDisplayName("MaxiStar")
        meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_ENCHANTS, ItemFlag.HIDE_UNBREAKABLE)
        itemMeta = meta
    }

    val brokenBeacon = ItemStack(Material.COAL_BLOCK).apply {
        val meta = itemMeta
        meta.setDisplayName("Broken Beacon")
        meta.addItemFlags(ItemFlag.HIDE_ENCHANTS, ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_UNBREAKABLE)
        meta.addEnchant(Enchantment.ARROW_INFINITE, 100, true)
        meta.lore = mutableListOf("Hmm...", "Maybe you should not have put it in the Blast Furnace...")
        itemMeta = meta
    }

    val metaGem = ItemStack(Material.EMERALD).apply {
        val meta = itemMeta
        meta.setDisplayName("MetaGem")
        meta.addAttributeModifier(
            Attribute.GENERIC_ATTACK_DAMAGE,
            AttributeModifier("Damage++", 100.0, AttributeModifier.Operation.ADD_NUMBER)
        )
    }

    override fun enable() {
        val recipe = ShapedRecipe(NamespacedKey(this, "maxi_recipe"), maxistar).shape("nnn", "nnn", "nnn")
            .setIngredient('n', Material.NETHER_STAR)

        Bukkit.addRecipe(recipe)
        val brokenBeaconRecipe =
            BlastingRecipe(NamespacedKey(this, "beacon_recipe"), brokenBeacon, Material.BEACON, 1.0f, 1000)
        Bukkit.addRecipe(brokenBeaconRecipe)
        server.pluginManager.registerEvents(ListenStuff(this), this)

        transaction {
            SchemaUtils.createMissingTablesAndColumns(StageKeepers)
        }

    }


    override fun disable() {
        val iter = Bukkit.recipeIterator()
        while (iter.hasNext()) {
            val it = iter.next()

            if (it.result in listOf(maxistar, brokenBeacon, metaGem)) {
                iter.remove()
            }
        }
    }

    class ListenStuff(private val bank: VoidOp) : Listener {
        @EventHandler
        fun blockPlace(evt: BlockPlaceEvent) {
            if (evt.itemInHand in mutableListOf(bank.maxistar, bank.metaGem, bank.brokenBeacon)) {
                evt.isCancelled = true
            }
        }

        @EventHandler
        fun itemPickup(evt: PlayerAttemptPickupItemEvent) {
            setStage(evt.player, evt.item.itemStack)
        }

        @EventHandler
        fun craftItem(evt: CraftItemEvent) {
            if (evt.whoClicked is Player)
                setStage(evt.whoClicked as Player, evt.recipe.result)
        }

        @EventHandler
        fun blockOpen(evt: PlayerInteractEvent) {
            if (evt.hasBlock()) {
                val bl = evt.clickedBlock!!
                if (bl is Beacon) {
                    if (bl.tier == 4)
                }
            }
        }

        private fun setStage(player: Player, itemStack: ItemStack) {
            transaction {
                val stageKeeper =
                    StageKeeper.find { StageKeepers.player eq player.uniqueId }.firstOrNull() ?: StageKeeper.new {
                        this.player = player.uniqueId
                        this.stage = Stage.PRE
                    }
                var stageChanged = false

                when (stageKeeper.stage) {
                    Stage.PRE -> {
                        val adv = Bukkit.getAdvancement(NamespacedKey.minecraft("nether/summon_wither"))!!
                        val a = player.getAdvancementProgress(adv)
                        if (a.isDone && itemStack.type == Material.NETHER_STAR) {
                            stageKeeper.stage = Stage.WITHER
                            stageChanged = true
                        }
                    }
                    Stage.WITHER -> TODO()
                    Stage.BEACON -> TODO()
                    Stage.MAXI -> TODO()
                    Stage.BROKEN -> TODO()
                    Stage.GOD -> TODO()
                }
                if (stageChanged) {
                    when (stageKeeper.stage) {
                        Stage.PRE -> TODO()
                        Stage.WITHER -> TODO()
                        Stage.BEACON -> TODO()
                        Stage.MAXI -> TODO()
                        Stage.BROKEN -> TODO()
                        Stage.GOD -> TODO()
                    }
                }

            }
        }
    }

    class ItemStackChoice(private val itemStack1: ItemStack) : RecipeChoice {
        override fun getItemStack(): ItemStack {
            return itemStack1
        }

        override fun clone(): RecipeChoice {
            return ItemStackChoice(itemStack1)
        }

        override fun test(itemStack: ItemStack): Boolean {
            return itemStack == itemStack1
        }
    }

    enum class Stage {
        PRE,
        WITHER,
        BEACON,
        MAXI,
        BROKEN,
        GOD
    }

}