TCOWW/src/main/kotlin/fr/azur/tcoww/commands/Power.kt

package fr.azur.tcoww.commands

import com.mojang.brigadier.Command
import com.mojang.brigadier.builder.LiteralArgumentBuilder
import fr.azur.tcoww.game.Game
import fr.azur.tcoww.roles.FortuneTeller
import fr.azur.tcoww.roles.Role
import fr.azur.tcoww.roles.Witch
import fr.azur.tcoww.utils.Stockage
import io.papermc.paper.command.brigadier.CommandSourceStack
import io.papermc.paper.command.brigadier.Commands
import io.papermc.paper.command.brigadier.argument.ArgumentTypes
import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver
import net.kyori.adventure.text.Component
import net.kyori.adventure.text.event.HoverEvent
import net.kyori.adventure.text.format.NamedTextColor
import org.bukkit.Bukkit
import org.bukkit.NamespacedKey
import org.bukkit.entity.Player
import org.bukkit.persistence.PersistentDataType
import org.bukkit.potion.PotionEffect
import org.bukkit.potion.PotionEffectType

class Power {
    val root: LiteralArgumentBuilder<CommandSourceStack> = Commands.literal("power")
        .requires { ctx -> ctx.sender as? Player != null && Role.getRole(ctx.sender as Player)?.hasPowerCommand == true }
        .then(
            Commands.literal("kill")
                .requires { ctx ->
                    val player = ctx.executor as? Player ?: return@requires false
                    val role = Role.getRole(player)
                    (role is Witch && player.hasPowerItem(1))
                }
                .then(
                    Commands.argument("target", ArgumentTypes.player())
                        .suggests { _, builder ->
                            Game.current?.playersMutable?.forEach { builder.suggest(it.name) }
                            builder.buildFuture()
                        }
                        .executes { ctx ->
                            val target = ctx.getTargetPlayer("target") ?: return@executes 0
                            val player = ctx.source.getPlayer() ?: return@executes 0
                            if (Game.current?.playersMutable?.contains(target) == true) {
                                target.addPotionEffect(PotionEffect(PotionEffectType.WITHER, 600, 4))
                                player.removePowerItem(1)
                            }
                            Command.SINGLE_SUCCESS
                        }
                )
        )
        .then(
            Commands.literal("save")
                .requires { ctx ->
                    val player = ctx.executor as? Player ?: return@requires false
                    val role = Role.getRole(player)
                    role is Witch && player.hasPowerItem(2)
                }
                .then(
                    Commands.argument("target", ArgumentTypes.player())
                        .executes { ctx ->
                            val target = ctx.getTargetPlayer("target") ?: return@executes 0
                            val player = ctx.source.getPlayer() ?: return@executes 0
                            if (Game.current?.playersMutable?.contains(target) == true &&
                                target.persistentDataContainer.get(
                                    NamespacedKey("tcoww", "dead"),
                                    PersistentDataType.BOOLEAN
                                ) == true
                            ) {
                                target.persistentDataContainer.set(
                                    NamespacedKey("tcoww", "dead"),
                                    PersistentDataType.BOOLEAN,
                                    false
                                )
                                Stockage.backLocation[target.uniqueId]?.let { target.teleport(it) }
                                target.isInvulnerable = false
                                target.sendMessage(Component.text("Vous avez été résucité.").color(NamedTextColor.AQUA))
                                player.sendMessage(
                                    Component.text("Vous avez résuciter ").color(NamedTextColor.AQUA)
                                        .append(player.displayName())
                                )
                                player.removePowerItem(2)
                            }
                            Command.SINGLE_SUCCESS
                        }
                )
        )
        .then(
            Commands.literal("view")
                .requires { ctx ->
                    val player = ctx.executor as? Player ?: return@requires false
                    val role = Role.getRole(player)
                    role is FortuneTeller && player.hasPowerItem(4)
                }
                .then(
                    Commands.argument("target", ArgumentTypes.player())
                        .suggests { _, builder ->
                            Game.current?.playersMutable?.forEach { builder.suggest(it.name) }
                            builder.buildFuture()
                        }
                        .executes { ctx ->
                            val target = ctx.getTargetPlayer("target") ?: return@executes 0
                            val player = ctx.source.getPlayer() ?: return@executes 0
                            val plugin = Bukkit.getPluginManager().getPlugin("tcoww") ?: return@executes 0
                            if (Game.current?.playersMutable?.contains(target) == true) {
                                val item = player.getPowerItem(4) ?: return@executes 0

                                val timeGestion = Game.current!!.timeGestion
                                val cooldown =
                                    ((timeGestion.dayDuration + timeGestion.voteDuration + timeGestion.nightDuration + timeGestion.crepuscularDuration - 30) * 2) * 20

                                val cloneditem = item.clone()

                                player.inventory.remove(item)

                                Bukkit.getScheduler().runTaskLater(plugin, Runnable {
                                    player.inventory.addItem(cloneditem)
                                }, cooldown.toLong())

                                val targetrole = Role.getRole(target)

                                player.sendMessage(
                                    target.displayName().append(Component.text(" est "))
                                        .append(
                                            (targetrole?.displayName ?: Component.text("Inconnu").hoverEvent(
                                                HoverEvent.showText(
                                                    targetrole?.description ?: Component.empty()
                                                )
                                            ))
                                        )
                                )
                            }
                            Command.SINGLE_SUCCESS
                        }
                )
        )

    private fun CommandSourceStack.getPlayer(): Player? = (this.executor ?: this.sender) as? Player

    private fun Player.hasPowerItem(id: Int): Boolean = this.inventory.any {
        it?.persistentDataContainer?.get(NamespacedKey("tcoww", "power"), PersistentDataType.INTEGER) == id
    }

    private fun Player.getPowerItem(id: Int) = this.inventory.firstOrNull {
        it?.persistentDataContainer?.get(NamespacedKey("tcoww", "power"), PersistentDataType.INTEGER) == id
    }

    private fun Player.removePowerItem(id: Int) {
        val item = getPowerItem(id) ?: return
        this.inventory.remove(item)
    }

    private fun com.mojang.brigadier.context.CommandContext<CommandSourceStack>.getTargetPlayer(name: String): Player? {
        val resolver = this.getArgument(name, PlayerSelectorArgumentResolver::class.java)
        return resolver.resolve(this.source).firstOrNull()
    }
}