using NUnit.Framework;
using ProjectM.Simulation;
using Unity.Mathematics;

namespace ProjectM.Tests
{
    /// <summary>
    /// Pure-function tests for <see cref="EnemyAIMath"/> (no ECS world), mirroring PlayerSpawnRingTests /
    /// StatMathTests. Pins the deterministic Husk seek / strike / spawn-ring math the server AI relies on.
    /// </summary>
    public class EnemyAIMathTests
    {
        const float Eps = 1e-4f;

        [Test]
        public void SeekVelocity_MovesTowardTarget_AtSpeed()
        {
            var v = EnemyAIMath.SeekVelocity(new float3(0, 1, 0), new float3(10, 1, 0), 4f, 0.5f);
            Assert.AreEqual(4f, math.length(v), Eps);
            Assert.Greater(v.x, 0f);
            Assert.AreEqual(0f, v.y, Eps);
            Assert.AreEqual(0f, v.z, Eps);
        }

        [Test]
        public void SeekVelocity_IgnoresVerticalSeparation()
        {
            // Target directly above (same XZ) is within stop distance on the plane -> no movement.
            var v = EnemyAIMath.SeekVelocity(new float3(0, 0, 0), new float3(0, 50, 0), 4f, 0.5f);
            Assert.AreEqual(0f, math.length(v), Eps);
        }

        [Test]
        public void SeekVelocity_ZeroWithinStopDistance()
        {
            var v = EnemyAIMath.SeekVelocity(new float3(0, 1, 0), new float3(0.3f, 1, 0), 4f, 0.5f);
            Assert.AreEqual(0f, math.length(v), Eps);
        }

        [Test]
        public void InAttackRange_TrueInside_FalseOutside()
        {
            Assert.IsTrue(EnemyAIMath.InAttackRange(new float3(0, 1, 0), new float3(1.0f, 1, 0), 1.5f));
            Assert.IsFalse(EnemyAIMath.InAttackRange(new float3(0, 1, 0), new float3(2.0f, 1, 0), 1.5f));
        }

        [Test]
        public void InAttackRange_IgnoresVertical()
        {
            // Same XZ, large Y gap -> still in range on the plane.
            Assert.IsTrue(EnemyAIMath.InAttackRange(new float3(0, 0, 0), new float3(0, 99, 0), 1.5f));
        }

        [Test]
        public void RingPosition_OnRadius_AroundCenter()
        {
            var center = new float3(5, 1, -3);
            var p = EnemyAIMath.RingPosition(center, 0, 8, 6f);
            var d = p - center;
            Assert.AreEqual(6f, math.length(new float2(d.x, d.z)), Eps); // planar distance == radius
            Assert.AreEqual(center.y, p.y, Eps);                          // stays on the plane
            // index 0, slots 8 -> angle 0 -> offset (+radius, 0, 0)
            Assert.AreEqual(center.x + 6f, p.x, Eps);
            Assert.AreEqual(center.z, p.z, Eps);
        }

        [Test]
        public void RingPosition_Deterministic_And_Distinct()
        {
            var c = float3.zero;
            var a = EnemyAIMath.RingPosition(c, 1, 8, 4f);
            var b = EnemyAIMath.RingPosition(c, 1, 8, 4f);
            Assert.AreEqual(a.x, b.x, Eps);
            Assert.AreEqual(a.z, b.z, Eps);
            var other = EnemyAIMath.RingPosition(c, 2, 8, 4f);
            Assert.Greater(math.distance(a, other), 1e-3f);
        }

        [Test]
        public void SlideVelocity_RemovesIntoWallComponent()
        {
            // Moving +X into a wall whose normal is -X (facing the mover): the into-wall component is removed.
            var slid = EnemyAIMath.SlideVelocity(new float3(4, 0, 0), new float3(-1, 0, 0));
            Assert.AreEqual(0f, math.length(slid), Eps);
        }

        [Test]
        public void SlideVelocity_KeepsParallelComponent()
        {
            // Moving diagonally into a wall with normal -X: the +X part is clipped, the +Z part survives.
            var slid = EnemyAIMath.SlideVelocity(new float3(3, 0, 5), new float3(-1, 0, 0));
            Assert.AreEqual(0f, slid.x, Eps);
            Assert.AreEqual(5f, slid.z, Eps);
            Assert.AreEqual(0f, slid.y, Eps);
        }

        [Test]
        public void SlideVelocity_FlattensNormalToPlane()
        {
            // A normal with a Y tilt is flattened to XZ before projecting, so vertical tilt never leaks in.
            var slid = EnemyAIMath.SlideVelocity(new float3(2, 0, 0), new float3(-1, 5, 0));
            Assert.AreEqual(0f, slid.x, Eps);
            Assert.AreEqual(0f, slid.y, Eps);
        }

        [Test]
        public void SlideVelocity_DegenerateNormal_ReturnsInput()
        {
            var v = new float3(2, 0, 3);
            var slid = EnemyAIMath.SlideVelocity(v, float3.zero);
            Assert.AreEqual(v.x, slid.x, Eps);
            Assert.AreEqual(v.z, slid.z, Eps);
        }
    }
}