using NUnit.Framework;
using ProjectM.Simulation;
using Unity.Core;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Transforms;

namespace ProjectM.Tests
{
    /// <summary>
    /// Plain-Entities determinism test for <see cref="PlayerMoveSystem"/> (the M1 predicted move
    /// system). Boots a bare ECS world, registers the system in the SimulationSystemGroup, creates a
    /// synthetic player (PlayerInput + PlayerMoveStats + LocalTransform + enabled Simulate), injects
    /// a fixed delta-time, ticks N times, and asserts the position advanced by exactly
    /// MoveSpeed * dt * N. Version-independent and netcode-free, mirroring HeartbeatSystemTests.
    /// </summary>
    public class PlayerMoveSystemTests
    {
        [Test]
        public void PlayerMove_Advances_By_MoveSpeed_Times_Dt_Each_Tick()
        {
            using var world = new World("PlayerMoveTestWorld");
            var simulationGroup = world.GetOrCreateSystemManaged<SimulationSystemGroup>();
            var moveSystem = world.GetOrCreateSystem<PlayerMoveSystem>();
            simulationGroup.AddSystemToUpdateList(moveSystem);
            simulationGroup.SortSystems();

            var em = world.EntityManager;
            var entity = em.CreateEntity(
                typeof(PlayerInput), typeof(PlayerMoveStats), typeof(LocalTransform), typeof(Simulate));

            const float moveSpeed = 5f;
            const float dt = 0.1f;
            const int ticks = 10;

            em.SetComponentData(entity, LocalTransform.FromPosition(float3.zero));
            em.SetComponentData(entity, new PlayerMoveStats { MoveSpeed = moveSpeed, TurnRateRadiansPerSec = 0f });
            em.SetComponentData(entity, new PlayerInput { Move = new float2(1f, 0f), Aim = float2.zero });

            for (int i = 0; i < ticks; i++)
            {
                // Fixed delta so the predicted move is fully deterministic (no wall-clock).
                world.SetTime(new TimeData(elapsedTime: dt * (i + 1), deltaTime: dt));
                simulationGroup.Update();
            }

            var position = em.GetComponentData<LocalTransform>(entity).Position;

            Assert.AreEqual(moveSpeed * dt * ticks, position.x, 1e-3f,
                "X should advance by MoveSpeed * dt each tick for Move=(1,0).");
            Assert.AreEqual(0f, position.y, 1e-3f, "Movement is planar; Y should stay 0.");
            Assert.AreEqual(0f, position.z, 1e-3f, "Move=(1,0) maps to +X only; Z should stay 0.");
        }

        [Test]
        public void PlayerMove_Is_Idempotent_Across_Equal_Tick_Batches()
        {
            // Determinism/idempotence: the same inputs and dt must yield the same result regardless
            // of how the ticks are grouped (mirrors the prediction loop re-simulating a tick).
            float3 RunTicks(int ticks)
            {
                using var world = new World("PlayerMoveDetWorld");
                var group = world.GetOrCreateSystemManaged<SimulationSystemGroup>();
                group.AddSystemToUpdateList(world.GetOrCreateSystem<PlayerMoveSystem>());
                group.SortSystems();

                var em = world.EntityManager;
                var e = em.CreateEntity(
                    typeof(PlayerInput), typeof(PlayerMoveStats), typeof(LocalTransform), typeof(Simulate));
                em.SetComponentData(e, LocalTransform.FromPosition(float3.zero));
                em.SetComponentData(e, new PlayerMoveStats { MoveSpeed = 3f, TurnRateRadiansPerSec = 0f });
                em.SetComponentData(e, new PlayerInput { Move = new float2(0f, 1f), Aim = float2.zero });

                for (int i = 0; i < ticks; i++)
                {
                    world.SetTime(new TimeData(0.05f * (i + 1), 0.05f));
                    group.Update();
                }

                return em.GetComponentData<LocalTransform>(e).Position;
            }

            var a = RunTicks(20);
            var b = RunTicks(20);
            Assert.AreEqual(a.z, b.z, 1e-4f, "Two identical runs must produce identical positions.");
            Assert.AreEqual(3f * 0.05f * 20f, a.z, 1e-3f, "Move=(0,1) maps to +Z by MoveSpeed*dt*N.");
        }
    }
}