using ProjectM.Simulation;
using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.NetCode;
using Unity.Physics;
using Unity.Transforms;

namespace ProjectM.Server
{
    /// <summary>
    /// Server-authoritative Husk AI: each tick every Husk seeks the nearest LIVING player and strikes on
    /// contact. Husks are OWNERLESS INTERPOLATED ghosts (not predicted), so this runs SERVER-ONLY in the plain
    /// <see cref="SimulationSystemGroup"/> — writing <see cref="LocalTransform"/> directly (replicated to clients
    /// by the stock LocalTransform default variant; no hand-written <c>[GhostField]</c>). Ordered
    /// <c>[UpdateAfter(PredictedSimulationSystemGroup)]</c> (the predicted group is OrderFirst, so UpdateBefore is ignored) so a contact <see cref="DamageEvent"/> appended this
    /// tick is drained the following tick by <see cref="HealthApplyDamageSystem"/> (which runs inside the predicted
    /// group on the server). No <c>Simulate</c> filter: interpolated ghosts are not predicted and the server has
    /// no rollback, so every Husk advances exactly once per tick. Movement/attack math is the pure, deterministic
    /// <see cref="EnemyAIMath"/>; server fixed-step <c>SystemAPI.Time.DeltaTime</c> is correct here (not the
    /// rollback loop). Structural-free: the only deferred op is appending to the player's DamageEvent buffer.
    /// </summary>
    [BurstCompile]
    [WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
    [UpdateInGroup(typeof(SimulationSystemGroup))]
    [UpdateAfter(typeof(PredictedSimulationSystemGroup))]
    public partial struct EnemyAISystem : ISystem
    {
        [BurstCompile]
        public void OnCreate(ref SystemState state)
        {
            state.RequireForUpdate<NetworkTime>();
            state.RequireForUpdate(state.GetEntityQuery(ComponentType.ReadOnly<EnemyTag>()));
        }

        [BurstCompile]
        public void OnUpdate(ref SystemState state)
        {
            // Snapshot living player targets once this tick (stable query order).
            var playerEntities = new NativeList<Entity>(Allocator.Temp);
            var playerPositions = new NativeList<float3>(Allocator.Temp);
            foreach (var (xform, health, entity) in
                     SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>>()
                         .WithAll<PlayerTag>()
                         .WithEntityAccess())
            {
                if (health.ValueRO.Current <= 0f)
                    continue; // don't chase or strike a corpse
                playerEntities.Add(entity);
                playerPositions.Add(xform.ValueRO.Position);
            }

            // EB-1 fortress aggro: also snapshot live structures (Turret/Wall/Pylon carry Health; automation
            // machines lack it so the query excludes them). Snapshot ABOVE the early-return so Husks keep razing
            // the base even with every player dead/away (the locked 'push for structures' fork).
            var structureEntities = new NativeList<Entity>(Allocator.Temp);
            var structurePositions = new NativeList<float3>(Allocator.Temp);
            foreach (var (sx, sh, se) in
                     SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>>()
                         .WithAll<PlacedStructure>()
                         .WithEntityAccess())
            {
                if (sh.ValueRO.Current <= 0f)
                    continue; // skip a structure already at 0 (pending destroy this tick)
                structureEntities.Add(se);
                structurePositions.Add(sx.ValueRO.Position);
            }

            // END-1: the Engine Core is a FALLBACK target. When no living player/structure remains, undefended
            // Husks march on the base heart (PlotCenter) so the base can be overrun instead of the swarm idling.
            bool coreAlive = SystemAPI.HasSingleton<BaseAnchor>()
                             && SystemAPI.TryGetSingleton<CoreIntegrity>(out var coreInteg) && coreInteg.Current > 0;
            float3 corePos = coreAlive ? BaseGridMath.PlotCenter(SystemAPI.GetSingleton<BaseAnchor>()) : float3.zero;

            if (playerEntities.Length == 0 && structureEntities.Length == 0 && !coreAlive)
            {
                playerEntities.Dispose();
                playerPositions.Dispose();
                structureEntities.Dispose();
                structurePositions.Dispose();
                return;
            }

            float dt = SystemAPI.Time.DeltaTime;
            var serverTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
            uint now = serverTick.TickIndexForValidTick;
            // Live feel knobs (MC-0): one read, guarded at use. Server-only — clients never simulate enemies.
            var tune = SystemAPI.TryGetSingleton<TuningConfig>(out var tcfg) ? tcfg : TuningConfig.Defaults();
            float structAggro = math.max(0f, tune.StructureAggroWeight);
            var ecb = new EntityCommandBuffer(Allocator.Temp);
            bool havePhysics = SystemAPI.TryGetSingleton<PhysicsWorldSingleton>(out var physics);
            uint envMask = SystemAPI.TryGetSingleton<WorldCollisionConfig>(out var worldCol) ? worldCol.EnvironmentMask : 0u;
            var envFilter = new CollisionFilter { BelongsTo = ~0u, CollidesWith = envMask, GroupIndex = 0 };
            bool sweep = havePhysics && envMask != 0u;
            const float SweepRadius = 0.5f; // collide-and-slide sphere radius for Husk movement

            foreach (var (xform, stats, cooldown, knockback, windup) in
                     SystemAPI.Query<RefRW<LocalTransform>, RefRO<EnemyStats>, RefRW<EnemyAttackCooldown>,
                             RefRW<KnockbackState>, RefRW<AttackWindup>>()
                         .WithAll<EnemyTag>().WithNone<LungeState>())
            {
                float3 pos = xform.ValueRO.Position;

                // Knockback overrides seek/strike for its window — EnemyAISystem stays the SOLE writer of Position.
                var kb = knockback.ValueRO;
                if (kb.UntilTick != 0)
                {
                    var kbTick = new NetworkTick(kb.UntilTick);
                    if (kbTick.IsValid && kbTick.IsNewerThan(serverTick))
                    {
                        float3 kpos = pos + new float3(kb.Dir.x, 0f, kb.Dir.y) * (kb.Speed * dt);
                        kpos.y = pos.y;
                        if (sweep)
                            kpos = SweptMove(in physics, pos, kpos, SweepRadius, envFilter);
                        xform.ValueRW.Position = kpos;
                        windup.ValueRW.WindUpUntilTick = 0; // a recoiling Husk does not wind up
                        continue; // recoiling: skip seek + strike this tick
                    }
                    knockback.ValueRW.UntilTick = 0; // window elapsed
                }

                // EB-1 fortress aggro: nearest of players (weight 1) + structures (StructureAggroWeight) — a wall/
                // turret is the preferred target unless a player is in the way (closer after weighting).
                EnemyAIMath.PickWeightedNearest(pos, playerPositions, structurePositions, structAggro, out bool tgtIsStruct, out int tgtIdx);
                if (tgtIdx < 0 && !coreAlive)
                    continue; // no player/structure and no Core -> nothing to seek
                Entity targetEntity = tgtIdx < 0 ? Entity.Null
                    : (tgtIsStruct ? structureEntities[tgtIdx] : playerEntities[tgtIdx]);
                float3 targetPos = tgtIdx < 0 ? corePos
                    : (tgtIsStruct ? structurePositions[tgtIdx] : playerPositions[tgtIdx]);

                // Seek: stop just inside strike range so the Husk holds position to attack.
                float stopDistance = stats.ValueRO.AttackRange * 0.9f;
                float3 vel = EnemyAIMath.SeekVelocity(pos, targetPos, stats.ValueRO.MoveSpeed, stopDistance);
                float3 newPos = pos + vel * dt;
                newPos.y = pos.y; // hold the movement plane
                if (sweep)
                    newPos = SweptMove(in physics, pos, newPos, SweepRadius, envFilter);
                xform.ValueRW.Position = newPos;

                // Face the target (planar) for presentation.
                float3 toTarget = targetPos - pos;
                toTarget.y = 0f;
                if (math.lengthsq(toTarget) > 1e-6f)
                    xform.ValueRW.Rotation = quaternion.LookRotationSafe(math.normalize(toTarget), math.up());

                // Two-phase strike with a telegraph wind-up: commit a wind-up when first in-range + cooldown-ready,
                // then strike when it elapses. WindUpUntilTick is a [GhostField] so the client can cue the ~0.3s
                // tell; leaving range mid-windup cancels it. Tuning.AttackWindupTicks = 0/1 -> near-instant (legacy).
                bool inRange = EnemyAIMath.InAttackRange(pos, targetPos, stats.ValueRO.AttackRange);
                uint windRaw = windup.ValueRO.WindUpUntilTick;

                if (windRaw != 0)
                {
                    if (!inRange)
                    {
                        windup.ValueRW.WindUpUntilTick = 0; // target left range -> cancel the wind-up
                    }
                    else
                    {
                        var windTick = new NetworkTick(windRaw);
                        if (!(windTick.IsValid && windTick.IsNewerThan(serverTick)))
                        {
                            if (targetEntity != Entity.Null) ecb.AppendToBuffer(targetEntity, new DamageEvent
                            {
                                Amount = stats.ValueRO.AttackDamage,
                                SourceNetworkId = -1, // environment / Husk, not a player
                                SourceTick = TickUtil.NonZero(now),
                            });
                            uint cooldownTicks = (uint)math.max(1, stats.ValueRO.AttackCooldownTicks);
                            cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + cooldownTicks);
                            windup.ValueRW.WindUpUntilTick = 0;
                        }
                    }
                }
                else if (inRange)
                {
                    uint nextRaw = cooldown.ValueRO.NextAttackTick;
                    bool ready = true;
                    if (nextRaw != 0)
                    {
                        var nextTick = new NetworkTick(nextRaw);
                        if (nextTick.IsValid && nextTick.IsNewerThan(serverTick))
                            ready = false;
                    }
                    if (ready)
                    {
                        uint windupTicks = (uint)math.max(1f, tune.GruntWindupTicks);
                        windup.ValueRW.WindUpUntilTick = TickUtil.NonZero(now + windupTicks);
                    }
                }
            }

            // --- Charger pass: a Husk variant baked with LungeState commits to a punishable fixed-direction lunge.
            // Component-presence is the discriminator; the Grunt pass above excludes these via .WithNone<LungeState>().
            // Charger feel knobs — live-tunable via TuningConfig (MC-0), guarded at the read site. Server-only
            // (clients never simulate Chargers); the >=1-tick floor avoids a degenerate instant/no-travel lunge.
            float ChargerLungeSpeed = math.max(0f, tune.ChargerLungeSpeed);        // units/s while lunging
            uint  ChargerLungeDurationTicks = (uint)math.max(1f, tune.ChargerLungeDurationTicks); // committed travel
            uint  ChargerWindupTicks = (uint)math.max(1f, tune.ChargerWindupTicks); // readable telegraph lead
            uint  ChargerWhiffStaggerTicks = (uint)math.max(1f, tune.ChargerWhiffStaggerTicks);   // punish window
            uint chargerWhiffsThisTick = 0;
            foreach (var (xform, stats, cooldown, knockback, windup, lunge) in
                     SystemAPI.Query<RefRW<LocalTransform>, RefRO<EnemyStats>, RefRW<EnemyAttackCooldown>,
                             RefRW<KnockbackState>, RefRW<AttackWindup>, RefRW<LungeState>>()
                         .WithAll<EnemyTag>())
            {
                float3 pos = xform.ValueRO.Position;

                // 1. Knockback wins (and cancels any in-flight lunge so Position keeps a single writer).
                var kb = knockback.ValueRO;
                if (kb.UntilTick != 0)
                {
                    var kbTick = new NetworkTick(kb.UntilTick);
                    if (kbTick.IsValid && kbTick.IsNewerThan(serverTick))
                    {
                        float3 kpos = pos + new float3(kb.Dir.x, 0f, kb.Dir.y) * (kb.Speed * dt);
                        kpos.y = pos.y;
                        if (sweep) kpos = SweptMove(in physics, pos, kpos, SweepRadius, envFilter);
                        xform.ValueRW.Position = kpos;
                        windup.ValueRW.WindUpUntilTick = 0;
                        lunge.ValueRW.UntilTick = 0;
                        continue;
                    }
                    knockback.ValueRW.UntilTick = 0;
                }

                // EB-1 fortress aggro: same weighted target selection as the Grunt pass (shared helper).
                EnemyAIMath.PickWeightedNearest(pos, playerPositions, structurePositions, structAggro, out bool cIsStruct, out int cIdx);
                if (cIdx < 0 && !coreAlive)
                    continue;
                Entity cTargetEntity = cIdx < 0 ? Entity.Null
                    : (cIsStruct ? structureEntities[cIdx] : playerEntities[cIdx]);
                float3 cTargetPos = cIdx < 0 ? corePos
                    : (cIsStruct ? structurePositions[cIdx] : playerPositions[cIdx]);

                // 2. Lunge active: travel the locked direction; damage on contact, or stagger on a wall-stop whiff.
                var lg = lunge.ValueRO;
                if (lg.UntilTick != 0)
                {
                    var lgTick = new NetworkTick(lg.UntilTick);
                    if (lgTick.IsValid && lgTick.IsNewerThan(serverTick))
                    {
                        float3 intended = pos + new float3(lg.Dir.x, 0f, lg.Dir.y) * (lg.Speed * dt);
                        intended.y = pos.y;
                        float3 moved = sweep ? SweptMove(in physics, pos, intended, SweepRadius, envFilter) : intended;
                        xform.ValueRW.Position = moved;
                        if (math.lengthsq(lg.Dir) > 1e-6f)
                            xform.ValueRW.Rotation = quaternion.LookRotationSafe(new float3(lg.Dir.x, 0f, lg.Dir.y), math.up());

                        if (EnemyAIMath.InAttackRange(moved, cTargetPos, stats.ValueRO.AttackRange))
                        {
                            if (cTargetEntity != Entity.Null) ecb.AppendToBuffer(cTargetEntity, new DamageEvent
                            {
                                Amount = stats.ValueRO.AttackDamage,
                                SourceNetworkId = -1,
                                SourceTick = TickUtil.NonZero(now),
                            });
                            uint cdTicks = (uint)math.max(1, stats.ValueRO.AttackCooldownTicks);
                            cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + cdTicks);
                            lunge.ValueRW.UntilTick = 0; // landed -> end the lunge
                        }
                        else
                        {
                            float intendedDist = math.distance(pos.xz, intended.xz);
                            float actualDist = math.distance(pos.xz, moved.xz);
                            if (intendedDist > 1e-4f && actualDist < intendedDist * 0.5f)
                            {
                                cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks);
                                lunge.ValueRW.UntilTick = 0; // wall-stop whiff -> stagger (the punish window)
                                chargerWhiffsThisTick++;
                                lunge.ValueRW.StaggerUntilTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks); // scoreable punish window
                            }
                        }
                        continue; // committed this tick
                    }

                    // Timer elapsed without landing -> overshoot whiff -> stagger, then seek this tick.
                    cooldown.ValueRW.NextAttackTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks);
                    lunge.ValueRW.UntilTick = 0;
                    chargerWhiffsThisTick++;
                    lunge.ValueRW.StaggerUntilTick = TickUtil.NonZero(now + ChargerWhiffStaggerTicks); // scoreable punish window
                }

                // 3. Seek + face (shared shape with the Grunt path).
                float cStop = stats.ValueRO.AttackRange * 0.9f;
                float3 cvel = EnemyAIMath.SeekVelocity(pos, cTargetPos, stats.ValueRO.MoveSpeed, cStop);
                float3 cNewPos = pos + cvel * dt; cNewPos.y = pos.y;
                if (sweep) cNewPos = SweptMove(in physics, pos, cNewPos, SweepRadius, envFilter);
                xform.ValueRW.Position = cNewPos;
                float3 cToTarget = cTargetPos - pos; cToTarget.y = 0f;
                if (math.lengthsq(cToTarget) > 1e-6f)
                    xform.ValueRW.Rotation = quaternion.LookRotationSafe(math.normalize(cToTarget), math.up());

                // 4. Commit: a wind-up elapses -> LOCK the lunge direction + fire. NO cancel-on-leave-range — the
                //    whole point is the commit lands even if the player dodged out of range (the punishable tell).
                uint cWindRaw = windup.ValueRO.WindUpUntilTick;
                if (cWindRaw != 0)
                {
                    var cWindTick = new NetworkTick(cWindRaw);
                    if (!(cWindTick.IsValid && cWindTick.IsNewerThan(serverTick)))
                    {
                        float3 toT = cTargetPos - pos; toT.y = 0f;
                        float2 ldir = math.lengthsq(toT) > 1e-6f ? math.normalize(toT.xz) : new float2(0f, 1f);
                        lunge.ValueRW.Dir = ldir;
                        lunge.ValueRW.Speed = ChargerLungeSpeed;
                        lunge.ValueRW.UntilTick = TickUtil.NonZero(now + ChargerLungeDurationTicks);
                        windup.ValueRW.WindUpUntilTick = 0;
                    }
                }
                else
                {
                    bool cInRange = EnemyAIMath.InAttackRange(pos, cTargetPos, stats.ValueRO.AttackRange);
                    if (cInRange)
                    {
                        bool cReady = cooldown.ValueRO.NextAttackTick == 0
                                      || !new NetworkTick(cooldown.ValueRO.NextAttackTick).IsNewerThan(serverTick);
                        if (cReady)
                            windup.ValueRW.WindUpUntilTick = TickUtil.NonZero(now + ChargerWindupTicks);
                    }
                }
            }

            // Slice 1 (Feature D): derive the replicated IsLunging cue ONCE per tick from the end-of-tick LungeState
            // (single point, idempotent — mirrors PlayerDeathStateSystem deriving Dead from Health). .WithPresent so a
            // Charger whose bit is currently DISABLED is still visited (Entities default-excludes disabled enableables).
            foreach (var (lunge, isLunging) in
                     SystemAPI.Query<RefRO<LungeState>, EnabledRefRW<IsLunging>>()
                         .WithAll<EnemyTag>().WithPresent<IsLunging>())
            {
                isLunging.ValueRW = lunge.ValueRO.UntilTick != 0u; // lunging iff a committed lunge is live this tick
            }

            if (chargerWhiffsThisTick != 0 && SystemAPI.HasSingleton<DevTelemetry>())
                SystemAPI.GetSingletonRW<DevTelemetry>().ValueRW.ChargerWhiffWindowsOpened += chargerWhiffsThisTick;

            ecb.Playback(state.EntityManager);

            ecb.Dispose();
            playerEntities.Dispose();
            playerPositions.Dispose();
            structureEntities.Dispose();
            structurePositions.Dispose();
        }

        // Swept collide-and-slide for server-authoritative Husk movement: sphere-cast the intended step against
        // the static environment (boundary ring + landmarks) and stop at / glance along the first wall hit. Closest-
        // hit SphereCast is non-generic -> Burst-safe (CLAUDE.md generic-collector hazard avoided). Y is held flat.
        static float3 SweptMove(in PhysicsWorldSingleton physics, float3 from, float3 to, float radius, CollisionFilter filter)
        {
            float3 delta = to - from;
            delta.y = 0f;
            float dist = math.length(delta);
            if (dist < 1e-5f)
                return to;
            float3 dir = delta / dist;
            const float skin = 0.05f;
            var cw = physics.CollisionWorld;
            if (!cw.SphereCast(from, radius, dir, dist, out var hit, filter))
                return to;

            float allowed = math.max(0f, hit.Fraction * dist - skin);
            float3 stop = from + dir * allowed;
            stop.y = from.y;

            // Slide the unused motion along the wall, then sweep the slide so we don't tunnel a second wall.
            float3 slide = EnemyAIMath.SlideVelocity(to - stop, hit.SurfaceNormal);
            float slideDist = math.length(slide);
            if (slideDist < 1e-5f)
                return stop;
            float3 sdir = slide / slideDist;
            float3 result = cw.SphereCast(stop, radius, sdir, slideDist, out var hit2, filter)
                ? stop + sdir * math.max(0f, hit2.Fraction * slideDist - skin)
                : stop + slide;
            result.y = from.y;
            return result;
        }
    }
}