import * as mc from "@minecraft/server"
import * as lib from "../lib"
import { Vector2, Vector3 } from "../lib/vector"

export function runEntity(entity = { typeId: "amor_stand" }, callback) {

    const dimensions = [
        mc.world.getDimension("overworld"),
        mc.world.getDimension("nether"),
        mc.world.getDimension("the_end")
    ]
    dimensions.forEach(dimension => {

        if (dimension.getPlayers() <= 0) { return }
        dimension.getEntities({ type: entity.typeId }).forEach(entity => { callback(entity) })


    })

    
}

export function spawnEntity(player, id = "ld_aw:skills.1.1", life = 1, transform = undefined) {

    const entity = player.dimension.spawnEntity(id, player.location);
    entity.teleport(entity.location, { rotation: transform.rotation })
    entity.nameTag = player.nameTag
  
    if (transform !== undefined) {
  
      entity.runCommand("tp ^" + (transform.position_block.x > 0 ? transform.position_block.x : "") + "^" + (transform.position_block.y > 0 ? transform.position_block.y: "") + "^" + (transform.position_block.z > 0 ? transform.position_block.z: ""))
  
  
    }
    mc.system.runTimeout(() => { try { entity.remove() } catch {} }, 20*life)
    return entity;
  
  
}

export const excludeTypes = [
    "minecraft:item",
    "minecraft:armor_stand",
    "minecraft:xp_orb",
    "minecraft:arrow",
    "ld_aw:none"
]
export const excludeFamilies = [
    "ld_aw:none"
]

/**
 * Expulsa os alvos para fora de um raio definido ao redor da entidade.
 * @param {mc.Entity} entity - A entidade central da barreira.
 * @param {number} radius - O raio em blocos dentro do qual os alvos serão expulsos.
 * @param {number} knockbackStrength - A força do knockback aplicado aos alvos.
 * @param {Array<string>} excludeFamilies - Famílias de entidades a serem excluídas.
 * @param {Array<string>} excludeTypes - Tipos de entidades a serem excluídas.
 */
export function expelTargetsFromRadius(entity, radius, knockbackStrength, excludeFamilies = [], excludeTypes = []) {
    // Adicione o tipo da entidade central à lista de exclusão para que não seja afetada
    excludeTypes.push(entity.typeId);

    // Obtenha todos os alvos dentro do raio especificado
    const targets = entity.dimension.getEntities({
        location: entity.location,
        maxDistance: radius,
        excludeFamilies: excludeFamilies,
        excludeTypes: excludeTypes
    });

    // Para cada alvo, calcula e aplica o knockback na direção oposta à entidade central
    targets.forEach(target => {
        const directionX = target.location.x - entity.location.x;
        const directionZ = target.location.z - entity.location.z;

        // Normaliza o vetor de direção para garantir a aplicação correta do knockback
        const magnitude = Math.sqrt(directionX * directionX + directionZ * directionZ);
        const normalizedDirectionX = directionX / magnitude;
        const normalizedDirectionZ = directionZ / magnitude;

        // Aplica o knockback para empurrar o alvo para fora do raio
        target.applyKnockback(normalizedDirectionX, normalizedDirectionZ, knockbackStrength, 0);
    });
}