import { world, system } from "@minecraft/server";
import { ConfigGeral } from "./config.js";

const cooldowns = new Map();

function getProp(player, chave) {
    return parseInt(player.getDynamicProperty(chave)) || 0;
}

function setProp(player, chave, valor) {
    player.setDynamicProperty(chave, valor);
}

world.beforeEvents.itemUse.subscribe((evento) => {
    const player = evento.source;
    const item = evento.itemStack;

    if (!item) return;

    const config = ConfigGeral.Genjutsu.Itens[item.typeId];

    if (config) {
        const agora = Date.now();
        const chaveCooldown = `${player.id}-${item.typeId}`;
        const ultimoUso = cooldowns.get(chaveCooldown) || 0;
        const tempoEspera = config.Cooldown * 1000;

        if (agora - ultimoUso < tempoEspera) {
            evento.cancel = true;
            const falta = Math.ceil((tempoEspera - (agora - ultimoUso)) / 1000);
            
            system.run(() => {
                player.sendMessage(`§cAguarde ${falta}s para usar novamente.`);
                player.playSound(ConfigGeral.Sons.Erro);
            });
            return;
        }

        if (config.Custo > 0) {
            const chakraAtual = getProp(player, "chakraCarga");
            if (chakraAtual < config.Custo) {
                evento.cancel = true;
                system.run(() => {
                    player.sendMessage(`§cChakra insuficiente! Necessário: ${config.Custo}`);
                    player.playSound(ConfigGeral.Sons.Erro);
                });
                return;
            }
            system.run(() => {
                setProp(player, "chakraCarga", chakraAtual - config.Custo);
            });
        }

        cooldowns.set(chaveCooldown, agora);
        
        system.run(() => {
            aplicarHabilidade(player, config);
        });
    }
});

function aplicarHabilidade(atacante, config) {
    const dimensao = atacante.dimension;
    const raio = ConfigGeral.Genjutsu.Raio;
    const isLiberar = config.Tipo === "liberar";

    const opcoes = {
        location: atacante.location,
        maxDistance: raio,
        excludeFamilies: ["inanimate"],
        excludeTypes: ["item", "xp_orb", "minecraft:arrow"]
    };

    const alvos = dimensao.getEntities(opcoes);
    let acertou = 0;

    alvos.forEach(alvo => {
        if (alvo.id === atacante.id) return;

        // 🔓 LIBERAR GENJUTSU
        if (isLiberar) {
            alvo.removeEffect("blindness");
            alvo.removeEffect("slowness");
            alvo.removeEffect("weakness");
            alvo.removeEffect("wither");
            alvo.removeEffect("nausea");
            alvo.removeEffect("levitation");
            alvo.removeEffect("mining_fatigue");
            acertou++;
            return;
        }

        // 🔒 IMUNIDADE (somente para genjutsu)
        if (config.Nivel > 0 && alvo.typeId === "minecraft:player") {
            const imune = ConfigGeral.Genjutsu.Imunidades.some(tag =>
                alvo.hasTag(tag)
            );
            if (imune) return;
        }

        // 🎭 APLICAR GENJUTSU
        config.Efeitos.forEach(ef => {
            if (ef.tempo > 0) {
                alvo.addEffect(ef.id, ef.tempo, { amplifier: ef.nivel });
            }
        });

        acertou++;
    });

    if (acertou > 0) {
        atacante.sendMessage(`§a${config.Nome} aplicado em ${acertou} alvos!`);
        atacante.playSound(
    isLiberar
        ? ConfigGeral.Sons.Sucesso
        : ConfigGeral.Sons.Genjutsu
);
    } else {
        atacante.sendMessage("§cNenhum alvo afetado.");
        atacante.playSound(ConfigGeral.Sons.Erro);
    }
}