// kamui-system.js
import { world, system } from "@minecraft/server";
import { ActionFormData } from "@minecraft/server-ui";

const KAMUI_COST = { activate: 500 };

world.afterEvents.worldInitialize.subscribe(ev => {
  const reg = ev.propertyRegistry;
  reg.registerEntityTypeDynamicProperties({ identifier: "kamui_locations", type: "string" }, "minecraft:player");
  reg.registerEntityTypeDynamicProperties({ identifier: "kamui_cooldown", type: "number" }, "minecraft:player");
});

function getProp(player, name) {
  return parseInt(player.getDynamicProperty(name)) || 0;
}
function setProp(player, name, val) {
  player.setDynamicProperty(name, val);
}
function consumirChakra(player, custo) {
  const chakra = getProp(player, "chakraCarga");
  if (chakra < custo) {
    player.sendMessage("§cSeu chakra não é suficiente!");
    return false;
  }
  setProp(player, "chakraCarga", chakra - custo);
  return true;
}

function getKamuiLocations(player) {
  try {
    const str = player.getDynamicProperty("kamui_locations");
    if (str) return JSON.parse(str);
  } catch {}
  return [];
}
function saveKamuiLocations(player, locations) {
  player.setDynamicProperty("kamui_locations", JSON.stringify(locations));
}

// ----------------------
// Menus de marcas
// ----------------------
function abrirMenuKamui(player) {
  const locais = getKamuiLocations(player);
  const form = new ActionFormData()
    .title(":zenkai_ui:✦ Sistema Kamui ✦")
    .body("§7Selecione o que deseja fazer:");
  form.button("§a➤ Criar nova marca");
  locais.forEach(loc => form.button(`§b➤ Ir para: ${loc.name}`));
  if (locais.length > 0) form.button("§c➤ Editar/Remover marcas");

  form.show(player).then(res => {
    if (res.canceled) return;
    if (res.selection === 0) {
      gerarNomeAutomatico(player);
      return;
    }
    if (locais.length > 0 && res.selection === locais.length + 1) {
      abrirMenuGerenciar(player);
      return;
    }
    const idx = res.selection - 1;
    if (idx >= 0 && idx < locais.length) iniciarTeleporte(player, locais[idx]);
  });
}
function gerarNomeAutomatico(player) {
  const locais = getKamuiLocations(player);
  const novoNome = `Marca ${locais.length + 1}`;
  marcarLocal(player, novoNome);
}
function marcarLocal(player, nome) {
  const locais = getKamuiLocations(player);
  const novo = {
    name: nome,
    x: Math.floor(player.location.x),
    y: Math.floor(player.location.y),
    z: Math.floor(player.location.z),
    dimension: player.dimension.id
  };
  locais.push(novo);
  saveKamuiLocations(player, locais);

  player.sendMessage(`§eMarca '${nome}' criada!`);
  player.runCommandAsync(`playsound seal_d @s ~ ~ ~ 1 1`);

  abrirMenuKamui(player);
}

function iniciarTeleporte(player, loc) {
  const dim = world.getDimension(loc.dimension || "minecraft:overworld");
  player.sendMessage(`§bVocê canaliza chakra e se move até '${loc.name}'...`);

  player.runCommandAsync(`playsound kamui @s ~ ~ ~ 1 1`);
  player.runCommandAsync(`playanimation @s animation.kamui_`);
  player.runCommandAsync(`effect @s slowness 5 9 true`);
  player.runCommandAsync(`camera @s set third_person_front`);

  let contador = 5;
  const intervalo = system.runInterval(() => {
    if (contador > 0) {
      player.sendMessage(`§eCanalizando chakra... ${contador}s`);
      contador--;
    } else {
      system.clearRun(intervalo);
      player.teleport({ x: loc.x + 0.5, y: loc.y, z: loc.z + 0.5 }, { dimension: dim });
      player.runCommandAsync(`camera @s set first_person`);
      player.sendMessage(`§aChegou em '${loc.name}'!`);
    }
  }, 20);
}

function abrirMenuGerenciar(player) {
  const locais = getKamuiLocations(player);
  if (locais.length === 0) {
    player.sendMessage("§cVocê não tem nenhuma marca Kamui!");
    abrirMenuKamui(player);
    return;
  }
  const form = new ActionFormData()
    .title(":zenkai_ui:✦ Gerenciar Marcas Kamui ✦")
    .body("§7Selecione uma marca para remover:");
  locais.forEach(loc => form.button(`§cRemover: ${loc.name}`));
  form.button("§9Voltar");
  form.show(player).then(res => {
    if (res.canceled) { abrirMenuKamui(player); return; }
    if (res.selection === locais.length) { abrirMenuKamui(player); return; }
    removerMarca(player, res.selection);
  });
}
function removerMarca(player, idx) {
  const locais = getKamuiLocations(player);
  if (idx >= 0 && idx < locais.length) {
    const removida = locais[idx];
    locais.splice(idx, 1);
    saveKamuiLocations(player, locais);
    player.sendMessage(`§cMarca '${removida.name}' removida!`);
  }
  abrirMenuKamui(player);
}

// ----------------------
// Ativação do Kamui
// ----------------------
let kamuiAtivo = false;
let npcKamui = null;

async function ativarKamui(player) {
  const cooldown = getProp(player, "kamui_cooldown");
  if (cooldown > Date.now()) {
    player.sendMessage("§cVocê ainda está em cooldown do Kamui!");
    return;
  }
  if (!consumirChakra(player, KAMUI_COST.activate)) return;

  if (kamuiAtivo && npcKamui) {
    puxarPlayers(player, npcKamui);
    return;
  }

  const limiteAltura = world.getDimension("minecraft:overworld").heightRange.max;
  const spawnY = limiteAltura - 25;
  const pos = { x: player.location.x, y: spawnY, z: player.location.z };
  const dimensao = player.dimension;

  await dimensao.runCommandAsync(`structure load kamui ${Math.floor(pos.x)} ${Math.floor(pos.y)} ${Math.floor(pos.z)}`);

  const encontrados = dimensao.getEntities({ type: "nz:kamui" });
  if (encontrados.length > 0) npcKamui = encontrados[0];

  kamuiAtivo = true;
  player.sendMessage("§6Kamui invocado! Contagem de 5 segundos...");

  const nearbyPlayers = dimensao.getPlayers({ location: player.location, maxDistance: 15 });
  nearbyPlayers.forEach(p => {
    p.runCommandAsync(`playsound kamui @s ~ ~ ~ 1 1`);
    p.runCommandAsync(`playanimation @s animation.kamui_`);
    p.runCommandAsync(`camera @s set third_person_front`);
  });

  // Slowness só no usuário que ativou
  player.runCommandAsync(`effect @s slowness 5 9 true`);

  let contador = 5;
  const intervalo = system.runInterval(() => {
    if (contador > 0) {
      world.sendMessage(`§eKamui ativando em ${contador}s...[Raio de 15 blocos]`);
      contador--;
    } else {
      system.clearRun(intervalo);

      // Volta todos para primeira pessoa antes de puxar
      nearbyPlayers.forEach(p => {
        p.runCommandAsync(`camera @s set first_person`);
      });

      puxarPlayers(player, npcKamui);
    }
  }, 20);
}

function puxarPlayers(user, npc) {
  const pegos = [];

  const entidades = npc.dimension.getEntities({ location: user.location, maxDistance: 15 });

  entidades.forEach(e => {
    if (e.typeId === "minecraft:player") {
      const novaMarca = {
        name: `Marca Kamui`,
        x: Math.floor(e.location.x),
        y: Math.floor(e.location.y),
        z: Math.floor(e.location.z),
        dimension: e.dimension.id
      };
      const locais = getKamuiLocations(e);
      locais.push(novaMarca);
      saveKamuiLocations(e, locais);

      e.teleport({ x: npc.location.x, y: npc.location.y + 3, z: npc.location.z }, { dimension: npc.dimension });
      e.sendMessage("§cVocê foi pego pelo Kamui!");
      if (e.id !== user.id) {
        user.sendMessage(`§aVocê prendeu o player ${e.name} no Kamui`);
      }
      pegos.push(e);
    } else {
      e.teleport({ x: npc.location.x, y: npc.location.y + 3, z: npc.location.z }, { dimension: npc.dimension });
      user.sendMessage("§aVocê prendeu um NPC no Kamui");
    }
  });

  user.sendMessage("§bVocê entrou no Kamui! Tempo: 1 minuto");

  // Após 50 segundos inicia contagem regressiva de 10s para sair
system.runTimeout(() => {
  let countdown = 10;
  world.sendMessage("§bUm grande Chakra te ajuda a sair...LP??");

  // Som + animação de saída para todos próximos
  const nearbyPlayers = npc.dimension.getPlayers({ location: npc.location, maxDistance: 15 });
  nearbyPlayers.forEach(p => {
    p.runCommandAsync(`playsound kamui @s ~ ~ ~ 1 1`);
    p.runCommandAsync(`playanimation @s animation.kamui_2`);
    p.runCommandAsync(`effect @s slowness 3 9 true`);
    p.runCommandAsync(`camera @s set third_person_front`);
  });

  // Mantém câmera frontal fixa por 3 segundos
  system.runTimeout(() => {
    nearbyPlayers.forEach(p => {
      p.runCommandAsync(`camera @s set first_person`);
    });
  }, 60); // 3 segundos = 60 ticks

  const intervalo = system.runInterval(() => {
    if (countdown > 0) {
      world.sendMessage(`§eRetorno em ${countdown}s...`);
      countdown--;
    } else {
      system.clearRun(intervalo);
    }
  }, 20);
}, 1000); // 50 segundos = 1000 ticks

  // Após 1 minuto retorna todos
  system.runTimeout(() => {
    pegos.forEach(p => {
      const locais = getKamuiLocations(p);
      if (locais.length > 0) {
        // Remove apenas a marca temporária "Marca Kamui"
        const ultima = locais.find(l => l.name === "Marca Kamui");
        if (ultima) {
          const dim = world.getDimension(ultima.dimension || "minecraft:overworld");
          p.teleport({ x: ultima.x, y: ultima.y, z: ultima.z }, { dimension: dim });
          p.sendMessage("§aVocê retornou da dimensão Kamui!");
          const filtrados = locais.filter(l => l.name !== "Marca Kamui");
          saveKamuiLocations(p, filtrados);
        }
      }
    });

    // Limpeza da dimensão
    npc.dimension.runCommandAsync(`kill @e[type=nz:kamui]`);
    npc.dimension.runCommandAsync(`fill ${npc.location.x - 25} ${npc.location.y - 25} ${npc.location.z - 25} ${npc.location.x + 25} ${npc.location.y + 25} ${npc.location.z + 25} air replace black_concrete`);
    npc.dimension.runCommandAsync(`fill ${npc.location.x - 25} ${npc.location.y - 25} ${npc.location.z - 25} ${npc.location.x + 25} ${npc.location.y + 25} ${npc.location.z + 25} air replace barrier`);
    npc.dimension.runCommandAsync(`fill ${npc.location.x - 25} ${npc.location.y - 25} ${npc.location.z - 25} ${npc.location.x + 25} ${npc.location.y + 25} ${npc.location.z + 25} air replace command_block`);
    npc.dimension.runCommandAsync(`fill ${npc.location.x - 25} ${npc.location.y - 25} ${npc.location.z - 25} ${npc.location.x + 25} ${npc.location.y + 25} ${npc.location.z + 25} air replace bedrock`);

    kamuiAtivo = false;
    npcKamui = null;

    // Cooldown de 3 minutos só para quem ativou
    setProp(user, "kamui_cooldown", Date.now() + 180000);
    user.sendMessage("§cVocê só poderá usar o Kamui novamente após 3 minutos!");
  }, 1200); // 1 minuto = 1200 ticks
}

// ----------------------
// Controle de uso do item
// ----------------------
world.afterEvents.itemUse.subscribe(ev => {
  const player = ev.source;
  const item = ev.itemStack;
  if (!item || item.typeId !== "nz:kamui_") return;

  // Se o jogador estiver agachado, abre o menu de marcas
  if (player.isSneaking) {
    abrirMenuKamui(player);
  } else {
    // Caso contrário, ativa o Kamui
    ativarKamui(player);
  }
});