package us.mcdevs.spigot.bettergraves

import org.bukkit.Material
import org.bukkit.NamespacedKey
import org.bukkit.block.Block
import org.bukkit.event.EventPriority
import org.bukkit.event.block.*
import org.bukkit.event.entity.PlayerDeathEvent
import org.bukkit.event.player.PlayerInteractEvent
import org.bukkit.persistence.PersistentDataHolder
import org.bukkit.persistence.PersistentDataType
import org.bukkit.plugin.java.JavaPlugin
import us.mcdevs.spigot.events.Events
import us.mcdevs.spigot.pluginapi.resource.ResourceManager
import us.mcdevs.spigot.pluginapi.resource.YAML_LOADER
import java.time.Instant
import kotlin.math.min

class BetterGraves : JavaPlugin() {
    private val ownerKey = NamespacedKey(this, "graveOwner")
    private val timestampKey = NamespacedKey(this, "graveTime")
    private lateinit var resourceManager: ResourceManager
    private lateinit var skullOwner: String

    override fun onEnable() {
        this.resourceManager = ResourceManager(this)
        val config = resourceManager.loadResource(YAML_LOADER, "config.yml")!!
        skullOwner = config.getString("skull-owner")!!
        Events.listen(this, EventPriority.LOWEST, this::onPlayerDied)
        Events.listen(this, EventPriority.LOWEST, this::onPlayerClaimGrave)
        Events.listen(this, EventPriority.LOWEST, this::onBlockBreak)
        Events.listen(this, EventPriority.LOWEST, this::onBlockExplode)
        Events.listen(this, EventPriority.LOWEST, this::onBlockPiston)
        Events.listen(this, EventPriority.LOWEST, this::onBlockDamage)
        Events.listen(this, EventPriority.LOWEST, this::onBlockDropItem)
    }

    private fun onPlayerDied(event: PlayerDeathEvent) {
        val player = event.entity
        event.droppedExp = 0
        event.drops.clear()

        val grave = Grave(
            player.uniqueId,
            Instant.now().toEpochMilli(),
            min(7 * player.level, 100),
            player.inventory.contents.toList(),
            player.location.block
        )
        grave.save(resourceManager)
        grave.render(ownerKey, timestampKey, skullOwner)
    }

    private fun onPlayerClaimGrave(event: PlayerInteractEvent) {
        val block = event.clickedBlock ?: return
        val graveData = extractGraveData(block) ?: return
        val owner = graveData[0] as String
        val timestamp = graveData[1] as Long

        val player = event.player
        val uuid = player.uniqueId

        val grave = Grave.load(uuid, timestamp, resourceManager)
        grave.applyTo(player)
        grave.delete(resourceManager)
        block.type = Material.AIR
    }

    private fun onBlockBreak(event: BlockBreakEvent) {
        val block = event.block
        extractGraveData(block) ?: return
        //Disallow breaking of graves
        event.isCancelled = true
    }

    private fun onBlockExplode(event: BlockExplodeEvent) {
        event.blockList().removeIf{
            val filter = extractGraveData(it) != null
            println("$it $filter")
            filter
        }
    }

    private fun onBlockDamage(event: BlockDamageEvent) {
        val block = event.block
        extractGraveData(block) ?: return
        event.isCancelled = true
    }

    private fun onBlockPiston(event: BlockPistonExtendEvent) {
        if (event.blocks.find { extractGraveData(it) != null } != null) {
            event.isCancelled = true
        }
    }

    private fun onBlockDropItem(event: BlockDropItemEvent) {
        val block = event.block
        extractGraveData(block) ?: return
        event.isCancelled = true
    }

    private fun extractGraveData(block: Block) : Array<Any>? {
        val tile = block.state
        if (tile !is PersistentDataHolder) return null
        val container = tile.persistentDataContainer
        val owner = container.get(ownerKey, PersistentDataType.STRING)
        val timestamp = container.get(timestampKey, PersistentDataType.LONG)
        if(owner == null || timestamp == null) return null
        return arrayOf(owner, timestamp)
    }
}