#if UNITY_EDITOR
using ProjectM.Simulation;
using Unity.Entities;
using Unity.Mathematics;
using Unity.NetCode;

namespace ProjectM.Client
{
    /// <summary>
    /// EDITOR-ONLY validation hook for driving the local player's <see cref="PlayerInput"/> without a
    /// real input device or a focused Game view. The Unity Input System ignores injected/real device
    /// input while the Game view is unfocused, which makes headless (MCP <c>execute_code</c>) or
    /// automated fire/move validation impossible through <see cref="PlayerInputGatherSystem"/> alone.
    /// <para>
    /// This system runs in <see cref="GhostInputSystemGroup"/> immediately AFTER the real gather and,
    /// when <see cref="Active"/> is set, overwrites the locally-owned player's input from static fields
    /// you can poke from a debugger / <c>execute_code</c> / an editor button. Because it writes the same
    /// <see cref="PlayerInput"/> the gather does, it drives the authentic command → prediction →
    /// AbilityFireSystem pipeline (not a shortcut), so it validates the real fire/move/auto-target path.
    /// </para>
    /// <para>
    /// Entirely wrapped in <c>#if UNITY_EDITOR</c>: it does not exist in player builds. Pair with
    /// <c>Application.runInBackground = true</c> so the unfocused editor keeps ticking. Usage from
    /// <c>execute_code</c>: <c>ProjectM.Client.DebugInputInjectionSystem.Fire();</c> (one shot),
    /// <c>...SetMove(0f, 1f);</c> (hold a move heading), <c>...SetAim(1f, 0f);</c>, <c>...Stop();</c>.
    /// </para>
    /// </summary>
    [UpdateInGroup(typeof(GhostInputSystemGroup))]
    [UpdateAfter(typeof(PlayerInputGatherSystem))]
    [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
    public partial class DebugInputInjectionSystem : SystemBase
    {
        /// <summary>While true, this system overrides the local player's gathered input each frame.</summary>
        public static bool Active;

        /// <summary>Movement heading applied to PlayerInput.Move while <see cref="Active"/>.</summary>
        public static float2 Move;

        /// <summary>Aim vector applied to PlayerInput.Aim while <see cref="Active"/> (zero = face movement).</summary>
        public static float2 Aim;

        /// <summary>Frames remaining to hold the Fire event. Each held frame raises Fire.Set(); holding
        /// across several frames spans multiple network ticks so the one-shot event reliably reaches the
        /// command buffer (a single-frame pulse can be lost across the frame→tick boundary). 0 = idle.</summary>
        public static int FireFrames;

        /// <summary>Convenience: hold Fire for the next <paramref name="frames"/> frames (also enables
        /// override). The ability cooldown still gates how many shots actually result.</summary>
        public static void Fire(int frames = 10) { Active = true; FireFrames = math.max(FireFrames, frames); }

        /// <summary>Convenience: hold a planar move heading (also enables override).</summary>
        public static void SetMove(float x, float z) { Active = true; Move = new float2(x, z); }

        /// <summary>Convenience: hold an aim direction (also enables override).</summary>
        public static void SetAim(float x, float z) { Active = true; Aim = new float2(x, z); }

        /// <summary>Convenience: stop overriding and clear all injected input.</summary>
        public static void Stop() { Active = false; Move = default; Aim = default; FireFrames = 0; }

        protected override void OnCreate()
        {
            RequireForUpdate<PlayerInput>();
        }

        protected override void OnUpdate()
        {
            if (!Active)
                return;

            bool fire = FireFrames > 0;
            if (FireFrames > 0) FireFrames--;
            float2 move = Move;
            float2 aim = Aim;

            foreach (var input in SystemAPI.Query<RefRW<PlayerInput>>().WithAll<GhostOwnerIsLocal>())
            {
                input.ValueRW.Move = move;
                input.ValueRW.Aim = aim;
                if (fire)
                    input.ValueRW.Fire.Set();
            }
        }
    }
}
#endif