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

const MANGEKYOU_MODOS = [
  "nz:mangekyou_rai","nz:mangekyou_naori","nz:mangekyou_naka","nz:mangekyou_shin",
  "nz:mangekyou_fugaku","nz:mangekyou_sarada","nz:mangekyou_baru","nz:mangekyou_sasuke",
  "nz:mangekyou_itachi","nz:mangekyou_izuna","nz:mangekyou_madara","nz:mangekyou_shisui","nz:mangekyou_kakashi",
  "nz:mangekyou_obito","nz:mangekyou_lp","nz:mangekyou_kaiser"
];

const IMMUNE_TAGS = ["dna_senju","dna_hagoromo"];

const quais = [...brutais];
const estadoplayeres = new Map();
const ciclosJashin = new Map();

const NOMES_EFEITOS = {
    strength: "Força",
    speed: "Velocidade",
    jump_boost: "Super Pulo",
    resistance: "Resistência",
    regeneration: "Regen",
    night_vision: "Visão Noturna",
    saturation: "Saturação",
    health_boost: "Vida Extra",
    hunger: "Fome",
    wither: "Wither",
    slowness: "Lentidão",
    weakness: "Fraqueza",
    mining_fatigue: "Fadiga"
};

// --- Intervalo da Cegueira Uchiha (1min30) ---
system.runInterval(() => {
  for (const player of world.getAllPlayers()) {
    try {
      // Verifica imunidade
      if (IMMUNE_TAGS.some(t => player.hasTag(t))) continue;

      const inventario = player.getComponent("equippable");
      if (!inventario) continue;

      const helmetId = inventario.getEquipment(EquipmentSlot.Head)?.typeId || "air";

      if (MANGEKYOU_MODOS.includes(helmetId)) {
        // Contagem regressiva de 5 segundos
        for (let i = 5; i > 0; i--) {
          system.runTimeout(() => {
            player.sendMessage(`§c[Alerta] Cegueira Uchiha em ${i}...`);
            player.runCommandAsync(`titleraw @s actionbar {"rawtext":[{"text":"§cCegueira Uchiha em ${i}..."}]}`);
          }, (5 - i) * 20);
        }

        // Aplica cegueira após 5 segundos
        system.runTimeout(() => {
          player.runCommandAsync(`effect @s blindness 5 1 true`);
        }, 5 * 20);
      }
    } catch (e) {
      console.warn("Erro ao aplicar cegueira:", e);
    }
  }
}, 20 * 90); // 90 segundos = 1800 ticks

// formata a mensagem única com todos os modos ativos e efeitos somados
function formatarMensagem(modosAtivos, efeitosSomados, healthBoostTotal, negativosSomados) {
    const nomesModos = modosAtivos.map(m => m.nome).join(" + ");
    let mensagem = `\n§l§b >> ${nomesModos} Ativo << §r\n`;
    const larguraNome = 16;

    for (const [efeito, nivel] of Object.entries(efeitosSomados)) {
        const nomeFormatado = NOMES_EFEITOS[efeito] || efeito;
        const nomeAlinhado = nomeFormatado.padEnd(larguraNome, " ");
        mensagem += `§f> §a${nomeAlinhado}: §f${nivel}\n`;
    }

    if (healthBoostTotal > 0) {
        const nomeAlinhado = NOMES_EFEITOS["health_boost"].padEnd(larguraNome, " ");
        mensagem += `§f> §b${nomeAlinhado}: §f${healthBoostTotal}\n`;
    }

    for (const [efeito, nivel] of Object.entries(negativosSomados)) {
        const nomeFormatado = NOMES_EFEITOS[efeito] || efeito;
        const nomeAlinhado = nomeFormatado.padEnd(larguraNome, " ");
        mensagem += `§f> §c${nomeAlinhado}: §f${nivel}\n`;
    }

    return mensagem;
}

// aplica os efeitos somados ao jogador
function aplicarEfeitosSomados(player, efeitosSomados, healthBoostTotal, negativosSomados) {
    // limpar efeitos antigos
    for (const efeito of Object.keys(NOMES_EFEITOS)) {
        player.runCommandAsync(`effect @s ${efeito} 0 0`);
    }

    // aplicar positivos
    for (const [efeito, nivel] of Object.entries(efeitosSomados)) {
        player.runCommandAsync(`effect @s ${efeito} 999999 ${nivel - 1} true`);
    }

    if (healthBoostTotal > 0) {
        player.runCommandAsync(`effect @s health_boost 999999 ${healthBoostTotal - 1} true`);
    }

    // aplicar negativos
    for (const [efeito, nivel] of Object.entries(negativosSomados)) {
        player.runCommandAsync(`effect @s ${efeito} 999999 ${nivel - 1} true`);
    }
}

// ciclo especial do modo jashin
function iniciarCicloJashin(player, modoBase) {
    ciclosJashin.set(player.id, true);

    aplicarEfeitosSomados(player, modoBase.efeitos || {}, modoBase.healthBoost || 0, modoBase.negativos || {});

    player.runCommandAsync("effect @s regeneration 30 255 true");
    player.sendMessage("§dJashin: Imortalidade por 30 segundos!");

    system.runTimeout(() => {
        if (!ciclosJashin.get(player.id)) return;

        player.runCommandAsync("effect @s regeneration 0 0");

        player.runCommandAsync("effect @s weakness 60 2 true");
        player.runCommandAsync("effect @s slowness 60 0 true");
        player.runCommandAsync("effect @s mining_fatigue 60 1 true");
        player.sendMessage("§cJashin: Fraqueza III, Lentidão I e Fadiga II por 1 minuto!");

        system.runTimeout(() => {
            if (!ciclosJashin.get(player.id)) return;

            player.sendMessage("§7Jashin em cooldown, aguarde 3 minutos...");

            system.runTimeout(() => {
                if (!ciclosJashin.get(player.id)) return;

                let segundos = 10;
                const countdown = () => {
                    if (!ciclosJashin.get(player.id)) return;
                    if (segundos > 0) {
                        player.sendMessage(`§eJashin: Imortalidade em ${segundos}...`);
                        segundos--;
                        system.runTimeout(countdown, 20);
                    } else {
                        const inventario = player.getComponent("equippable");
                        if (!inventario) return;
                        const itemCabeca = inventario.getEquipment(EquipmentSlot.Head);
                        const itemPeito = inventario.getEquipment(EquipmentSlot.Chest);
                        const itemBota = inventario.getEquipment(EquipmentSlot.Feet);
                        const idCabeca = itemCabeca ? itemCabeca.typeId : "air";
                        const idPeito = itemPeito ? itemPeito.typeId : "air";
                        const idBota = itemBota ? itemBota.typeId : "air";

                        if (idCabeca === "nz:modo_jashin" || idPeito === "nz:modo_jashin" || idBota === "nz:modo_jashin") {
                            iniciarCicloJashin(player, modoBase);
                        } else {
                            ciclosJashin.set(player.id, false);
                            player.sendMessage("§cJashin desativado (item removido).");
                        }
                    }
                };
                countdown();
            }, 20 * 170);
        }, 20 * 60);
    }, 20 * 30);
}

// loop principal
system.runInterval(() => {
    for (const player of world.getAllPlayers()) {
        const inventario = player.getComponent("equippable");
        if (!inventario) continue;

        const ids = [
            inventario.getEquipment(EquipmentSlot.Head)?.typeId || "air",
            inventario.getEquipment(EquipmentSlot.Chest)?.typeId || "air",
            inventario.getEquipment(EquipmentSlot.Feet)?.typeId || "air"
        ];

        const modosAtivos = ids
            .map(id => quais.find(m => m.id === id))
            .filter(m => m);

        // se não mudou, não faz nada
        const ultimo = estadoplayeres.get(player.id) || [];
        const nomesUltimos = ultimo.map(m => m.id).join(",");
        const nomesAtivos = modosAtivos.map(m => m.id).join(",");
        if (nomesUltimos === nomesAtivos) continue;

        estadoplayeres.set(player.id, modosAtivos);

        const efeitosSomados = {};
        let healthBoostTotal = 0;
        const negativosSomados = {};

        for (const modo of modosAtivos) {
            if (modo.efeitos) {
                for (const [efeito, nivel] of Object.entries(modo.efeitos)) {
                    efeitosSomados[efeito] = (efeitosSomados[efeito] || 0) + (nivel + 1);
                }
            }
            if (modo.healthBoost) {
                healthBoostTotal += modo.healthBoost + 1;
            }
            if (modo.negativos) {
                for (const [efeito, nivel] of Object.entries(modo.negativos)) {
                    negativosSomados[efeito] = (negativosSomados[efeito] || 0) + (nivel + 1);
                }
            }
            if (modo.id === "nz:modo_jashin") {
                if (!ciclosJashin.get(player.id)) {
                    iniciarCicloJashin(player, modo);
                }
            }
        }

// aplicar limites
if (efeitosSomados["resistance"] > 4) efeitosSomados["resistance"] = 4;
if (efeitosSomados["strength"] > 8) efeitosSomados["strength"] = 8;

aplicarEfeitosSomados(player, efeitosSomados, healthBoostTotal, negativosSomados);

// --- NOVO: aplica instant health por 3 segundos ---
player.runCommandAsync("effect @s instant_health 3 255 true");

// mensagem única só quando muda
const msg = formatarMensagem(modosAtivos, efeitosSomados, healthBoostTotal, negativosSomados);
player.sendMessage(msg);
    }
}, 20); // a cada segundo