import { world } from "@minecraft/server";

/**
 * Comprueba si el jugador está mirando directamente a la cabeza de la entidad objetivo y ejecuta los comandos necesarios.
 * @param {Entity} player - El jugador.
 */
export function isLookingAtHead(player) {
    const targetEntityId = "dungeon:gorgona";
    const initialCommands = [
        "tag @s add stone",
        "scoreboard players reset @s stonetest",
        "inputpermission set @s camera disabled",
        "inputpermission set @s movement disabled"
    ];
    const finalCommands = [
    ];

    const dimension = player.dimension;
    let timer = player.getDynamicProperty("gorgonaTimer") || 0;

    // Verificar el modo de juego del jugador
    const gameMode = player.getGameMode();
    if (gameMode !== "survival" && gameMode !== "adventure") {
        return; // Salir si el jugador no está en modo supervivencia o aventura
    }

    // Buscar entidades "dungeon:gorgona" cercanas
    const entities = dimension.getEntities({
        type: targetEntityId,
        location: player.location,
        maxDistance: 24
    });

    let isLooking = false;

    for (const target of entities) {
        const playerHeadPos = player.getHeadLocation();
        const targetHeadPos = target.getHeadLocation();

        const direction = player.getViewDirection();
        const toTarget = {
            x: targetHeadPos.x - playerHeadPos.x,
            y: targetHeadPos.y - playerHeadPos.y,
            z: targetHeadPos.z - playerHeadPos.z
        };

        // Normalizar el vector hacia el objetivo
        const toTargetMagnitude = Math.sqrt(toTarget.x ** 2 + toTarget.y ** 2 + toTarget.z ** 2);
        if (toTargetMagnitude === 0) continue; // Evitar división por cero

        const normalizedToTarget = {
            x: toTarget.x / toTargetMagnitude,
            y: toTarget.y / toTargetMagnitude,
            z: toTarget.z / toTargetMagnitude
        };

        // Producto escalar para comprobar la alineación del ángulo de visión
        const dotProduct = direction.x * normalizedToTarget.x + direction.y * normalizedToTarget.y + direction.z * normalizedToTarget.z;

        // Verificar obstrucción manualmente
        let isObstructed = false;
        const steps = Math.ceil(toTargetMagnitude * 10); // Más pasos para mayor precisión
        for (let i = 1; i < steps; i++) {
            const checkPos = {
                x: playerHeadPos.x + normalizedToTarget.x * (i / steps) * toTargetMagnitude,
                y: playerHeadPos.y + normalizedToTarget.y * (i / steps) * toTargetMagnitude,
                z: playerHeadPos.z + normalizedToTarget.z * (i / steps) * toTargetMagnitude
            };
            const block = dimension.getBlock({
                x: Math.floor(checkPos.x),
                y: Math.floor(checkPos.y),
                z: Math.floor(checkPos.z)
            });

            if (block && block.typeId !== "minecraft:air") {
                isObstructed = true;
                break;
            }
        }

        // Si el jugador está mirando directamente a la cabeza y no hay obstrucción
        if (dotProduct > 0.995 && !isObstructed) {
            isLooking = true;
            break;
        }
    }

    if (isLooking) {
        // Incrementar el temporizador
        timer++;
        player.runCommand("damage @s 1");

        if (timer === 1) {
            // Ejecutar comandos iniciales solo una vez
            for (const command of initialCommands) {
                player.runCommand(command);
            }
        }

        if (timer >= 200) {
            for (const command of finalCommands) {
                player.runCommand(command);
            }
            timer = 0; // Reiniciar temporizador
        }
    } else {
        timer = 0; // Reiniciar temporizador si no está mirando
    }

    // Almacenar el temporizador como propiedad dinámica
    player.setDynamicProperty("gorgonaTimer", timer);
}