using ProjectM.Simulation;
using Unity.Burst;
using Unity.Entities;
using Unity.Mathematics;
using Unity.NetCode;

namespace ProjectM.Server
{
    /// <summary>
    /// Server-authoritative macro-loop director for the PLAYER-DRIVEN loop. The base sits in <c>Calm</c>
    /// (persistent, unhurried — build/prep at your pace, no countdown) until the <see cref="ThreatState"/> arms a
    /// siege, then flips to <c>Siege</c> (the base-defense wave) and back to <c>Calm</c> when the wave is cleared.
    /// There is no global "Expedition" phase — being out on an expedition is per-player presence (server-only
    /// <see cref="RegionTag"/>), read client-side by the HUD, so one global byte never has to represent
    /// "player A out / player B home." Maintains the replicated <see cref="CycleState"/> singleton and gates
    /// <see cref="WaveSystem"/> (waves spawn only during Siege). Runs in the plain server SimulationSystemGroup
    /// before WaveSystem. All timing is wrap-safe NetworkTick math (<see cref="ProjectM.Simulation.TickUtil.NonZero"/>
    /// + <see cref="Unity.NetCode.NetworkTick.IsNewerThan"/>), never raw uint compares. Lives on the
    /// runtime-spawned CycleDirector ghost. Supersedes the forced timed Expedition→Defend→Build cycle.
    /// </summary>
    [BurstCompile]
    [WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
    [UpdateInGroup(typeof(SimulationSystemGroup))]
    [UpdateBefore(typeof(WaveSystem))]
    public partial struct CyclePhaseSystem : ISystem
    {
        EntityQuery m_AliveHusks;

        [BurstCompile]
        public void OnCreate(ref SystemState state)
        {
            state.RequireForUpdate<NetworkTime>();
            state.RequireForUpdate<CycleState>();
            m_AliveHusks = state.GetEntityQuery(ComponentType.ReadOnly<EnemyTag>());
        }

        [BurstCompile]
        public void OnUpdate(ref SystemState state)
        {
            var serverTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
            if (!serverTick.IsValid)
                return;
            uint now = serverTick.TickIndexForValidTick;

            var cycleEntity = SystemAPI.GetSingletonEntity<CycleState>();
            var cycle = SystemAPI.GetComponent<CycleState>(cycleEntity);
            var runtime = SystemAPI.GetComponent<CycleRuntime>(cycleEntity);

            if (cycle.Phase == CyclePhase.Calm)
            {
                // Default calm: no pending siege => no countdown.
                cycle.PhaseEndTick = 0;

                if (SystemAPI.HasComponent<ThreatState>(cycleEntity))
                {
                    var threat = SystemAPI.GetComponent<ThreatState>(cycleEntity);
                    if (threat.PendingSiegeSize > 0)
                    {
                        // Telegraph: mirror the arm tick into the replicated PhaseEndTick so the HUD can show an
                        // "incursion in Ns" countdown (reuses the existing HUD countdown path) while it arms.
                        cycle.PhaseEndTick = threat.ArmTick;

                        bool armed = threat.ArmTick == 0
                                     || !new NetworkTick(threat.ArmTick).IsNewerThan(serverTick);

                        if (armed && SystemAPI.TryGetSingletonEntity<WaveState>(out var waveEntity))
                        {
                            // ---- Calm -> Siege: seed WaveSystem's own Spawning entry atomically. Writing
                            // Phase=Spawning bypasses its Lull escalation recompute (WaveSystem only recomputes
                            // RemainingToSpawn while Phase==Lull), so the siege spawns EXACTLY the director-chosen
                            // size and WaveSystem stays the sole WaveState writer thereafter. ----
                            var w = SystemAPI.GetComponent<WaveState>(waveEntity);
                            runtime.DefendStartWave = w.WaveNumber;     // capture BEFORE the bump (DefendCleared tests > this)
                            w.WaveNumber += 1;
                            w.Phase = WavePhase.Spawning;
                            w.RemainingToSpawn = math.max(1, threat.PendingSiegeSize);
                            w.NextActionTick = TickUtil.NonZero(now);   // spawn the first Husk this tick
                            SystemAPI.SetComponent(waveEntity, w);

                            cycle.Phase = CyclePhase.Siege;
                            cycle.PhaseEndTick = 0;                      // Siege is wave-driven, not timed.

                            threat.PendingSiegeSize = 0;                 // consume once
                            threat.ArmTick = 0;
                            SystemAPI.SetComponent(cycleEntity, threat);
                        }
                    }
                }
            }
            else if (cycle.Phase == CyclePhase.Siege)
            {
                if (DefendCleared(ref state, runtime.DefendStartWave))
                {
                    cycle.Phase = CyclePhase.Calm;
                    cycle.PhaseEndTick = 0;
                    // Long-arc goal: +1 per siege survived (single writer; was +1 per completed timed cycle).
                    if (SystemAPI.HasComponent<GoalProgress>(cycleEntity))
                    {
                        var goal = SystemAPI.GetComponent<GoalProgress>(cycleEntity);
                        goal.Charge += 1;
                        SystemAPI.SetComponent(cycleEntity, goal);
                    }
                }
            }

            // Surface the live wave number on the replicated CycleState for the HUD (single writer).
            if (SystemAPI.TryGetSingleton<WaveState>(out var waveSync))
                cycle.WaveNumber = waveSync.WaveNumber;

            SystemAPI.SetComponent(cycleEntity, cycle);
            SystemAPI.SetComponent(cycleEntity, runtime);
        }

        // The Siege wave has run for this phase (WaveNumber advanced past the captured start), is fully spawned,
        // and no Husks remain alive.
        bool DefendCleared(ref SystemState state, int defendStartWave)
        {
            if (!SystemAPI.TryGetSingleton<WaveState>(out var wave))
                return false;
            return wave.WaveNumber > defendStartWave
                   && wave.RemainingToSpawn == 0
                   && m_AliveHusks.CalculateEntityCount() == 0;
        }
    }
}