using System;
using System.Collections.Generic;
using System.Linq;
using CounterDrone.Core.Models;

namespace CounterDrone.Core.Algorithms
{
    /// <summary>默认防御规划器 — 五步流水线，全部使用真实物理计算</summary>
    public class DefaultDefensePlanner : IDefensePlanner
    {
        private readonly List<AmmunitionSpec> _ammoCatalog;

        public DefaultDefensePlanner(List<AmmunitionSpec> ammoCatalog)
        {
            _ammoCatalog = ammoCatalog ?? new List<AmmunitionSpec>();
        }

        private static readonly Dictionary<PowerType, AerosolType> MatchTable = new()
        {
            { PowerType.Electric, AerosolType.InertGas },
            { PowerType.Piston,   AerosolType.InertGas },
            { PowerType.Jet,      AerosolType.ActiveMaterial },
        };

        private static readonly Dictionary<TargetType, float> TypeCoefficient = new()
        {
            { TargetType.HighSpeed,  4f },
            { TargetType.FixedWing,  2f },
            { TargetType.Piston,     2f },
            { TargetType.Rotor,      1f },
            { TargetType.Electric,   1f },
        };

        // ═══════════════════════════════════════════════
        // 五步流水线
        // ═══════════════════════════════════════════════

        public PlannerResult Plan(List<FireUnit> fireUnits, List<DroneGroup> threats, CombatScene environment)
        {
            var result = new PlannerResult();

            if (threats.Count == 0)
            {
                result.Best.Summary = "无威胁目标";
                return result;
            }
            if (fireUnits.Count == 0)
            {
                result.Best.Summary = "无可用火力单元";
                result.Best.ThreatsUnengaged = threats.Count;
                return result;
            }

            // Step 1: 威胁排序
            foreach (var t in threats)
            {
                t.ArrivalTime = t.GetArrivalTime();
                t.ThreatIndex = CalcThreatIndex(t.Target);
            }
            var sorted = threats.OrderByDescending(t => t.Priority).ToList();

            // Step 2-4: 贪心分配求解
            result.Best = Solve(sorted, fireUnits, environment);

            // Step 5: 临界方案
            result.Critical = DeriveCritical(result.Best);

            return result;
        }

        // ═══════════════════════════════════════════════
        // Step 1: 威胁指数
        // ═══════════════════════════════════════════════

        private static float CalcThreatIndex(TargetConfig target)
        {
            float typeCoef = TypeCoefficient.GetValueOrDefault((TargetType)target.TargetType, 1f);
            float speedCoef = (float)target.TypicalSpeed / 60f;
            return typeCoef * speedCoef;
        }

        // ═══════════════════════════════════════════════
        // Step 2: 弹药匹配
        // ═══════════════════════════════════════════════

        private static AerosolType MatchAmmo(PowerType power)
        {
            return MatchTable.GetValueOrDefault(power, AerosolType.InertGas);
        }

        // ═══════════════════════════════════════════════
        // Step 3-4: 候选生成 → 贪心分配
        // ═══════════════════════════════════════════════

        private DefensePlan Solve(List<DroneGroup> sortedThreats,
            List<FireUnit> fireUnits, CombatScene env)
        {
            var plan = new DefensePlan();
            var remainingMunitions = new Dictionary<string, int>();
            foreach (var u in fireUnits)
                remainingMunitions[u.Id] = u.TotalMunitions;

            foreach (var threat in sortedThreats)
            {
                var available = fireUnits
                    .Where(u => remainingMunitions.GetValueOrDefault(u.Id, 0) > 0)
                    .ToList();

                var candidates = GenerateCandidates(threat, available, env);
                if (candidates.Count == 0)
                {
                    plan.ThreatsUnengaged++;
                    continue;
                }

                // 计算总弹药需求
                var neededAmmo = MatchAmmo((PowerType)threat.Target.PowerType);
                var ammo = _ammoCatalog.FirstOrDefault(a => a.AerosolType == (int)neededAmmo);
                int totalRoundsNeeded = CalcRoundsNeeded(threat, ammo, env,
                    candidates[0].Unit.Type == PlatformType.AirBased);

                // 从多个候选单元凑弹药，直到满足需求或耗尽
                int roundsCollected = 0;
                var assignedUnits = new List<(FireUnit unit, int rounds, List<FireEvent> events)>();

                foreach (var c in candidates.OrderBy(c => c.EarliestInterceptTime)
                    .ThenByDescending(c => c.KillProbability))
                {
                    if (roundsCollected >= totalRoundsNeeded) break;
                    int remaining = remainingMunitions.GetValueOrDefault(c.Unit.Id, 0);
                    if (remaining <= 0) continue;

                    int toTake = Math.Min(remaining, totalRoundsNeeded - roundsCollected);
                    var fireEvents = GenerateFireEvents(threat, c.Unit, c.AmmoType, toTake, ammo, env);
                    assignedUnits.Add((c.Unit, toTake, fireEvents));
                    remainingMunitions[c.Unit.Id] -= toTake;
                    roundsCollected += toTake;
                }

                if (roundsCollected <= 0) { plan.ThreatsUnengaged++; continue; }

                foreach (var (unit, rounds, fireEvents) in assignedUnits)
                {
                    plan.Assignments.Add(new UnitAssignment
                    {
                        FireUnitId = unit.Id,
                        DroneGroupId = threat.GroupId,
                        AmmoType = neededAmmo,
                        RoundsFired = rounds,
                        FirstFireTime = fireEvents.Count > 0 ? fireEvents[0].FireTime : 0,
                        FireEvents = fireEvents,
                    });
                    plan.MergedSchedule.AddRange(fireEvents);
                }

                plan.ThreatsEngaged++;
            }

            plan.MergedSchedule.Sort((a, b) => a.FireTime.CompareTo(b.FireTime));

            // 按威胁汇总概率
            var threatProbs = new List<float>();
            foreach (var threat in sortedThreats)
            {
                var a2 = _ammoCatalog.FirstOrDefault(s =>
                    s.AerosolType == (int)MatchAmmo((PowerType)threat.Target.PowerType));
                int totalRounds = plan.Assignments
                    .Where(a => a.DroneGroupId == threat.GroupId)
                    .Sum(a => a.RoundsFired);
                if (totalRounds > 0)
                    threatProbs.Add(ComputeInterceptProbability(threat, a2, totalRounds, env));
            }
            plan.OverallProbability = threatProbs.Count > 0 ? threatProbs.Average() : 0f;
            plan.Summary = plan.ThreatsEngaged > 0
                ? $"分配 {plan.ThreatsEngaged} 个威胁，{plan.ThreatsUnengaged} 个无方案"
                : "无威胁被分配拦截方案";

            return plan;
        }

        // ═══════════════════════════════════════════════
        // 候选生成（使用真实物理）
        // ═══════════════════════════════════════════════

        private List<InterceptCandidate> GenerateCandidates(DroneGroup threat,
            List<FireUnit> availableUnits, CombatScene env)
        {
            var candidates = new List<InterceptCandidate>();
            var neededAmmo = MatchAmmo((PowerType)threat.Target.PowerType);
            var ammo = _ammoCatalog.FirstOrDefault(a => a.AerosolType == (int)neededAmmo);
            if (ammo == null) return candidates;

            var ammoEff = ComputeEffectiveRadius(threat, ammo, env);

            foreach (var unit in availableUnits)
            {
                if (!unit.AmmoTypes.Contains(neededAmmo)) continue;

                if (unit.Type == PlatformType.AirBased)
                {
                    var c = BuildAirBasedCandidate(threat, unit, neededAmmo, ammo, ammoEff, env);
                    if (c != null) candidates.Add(c);
                }
                else
                {
                    var c = BuildGroundBasedCandidate(threat, unit, neededAmmo, ammo, ammoEff, env);
                    if (c != null) candidates.Add(c);
                }
            }

            return candidates;
        }

        private InterceptCandidate? BuildGroundBasedCandidate(DroneGroup threat,
            FireUnit unit, AerosolType ammoType, AmmunitionSpec ammo,
            (float radius, float expTime) ammoEff, CombatScene env)
        {
            var mid = ThreatMidpoint(threat);
            float dx = mid.X - unit.Position.X;
            float dz = mid.Z - unit.Position.Z;
            float dist = (float)Math.Sqrt(dx * dx + dz * dz);

            float maxRange = unit.MuzzleVelocity * unit.MuzzleVelocity / 9.81f;
            if (dist > maxRange * 0.8f) return null;

            float shellTime = dist / unit.MuzzleVelocity;
            float interceptTime = threat.ArrivalTime;

            float avgSpeed = (float)threat.Target.TypicalSpeed / 3.6f;
            float neededExposure = ammoType == AerosolType.ActiveMaterial ? 2f : 6f;
            float actualExposure = ammoEff.radius * 2f / avgSpeed;
            float prob = Math.Min(0.95f, actualExposure / neededExposure);

            return new InterceptCandidate
            {
                Unit = unit,
                AmmoType = ammoType,
                EarliestInterceptTime = interceptTime,
                CoverageDuration = ammoEff.radius * 2f,
                KillProbability = prob,
                FlightTime = shellTime,
                ShellFlightTime = shellTime,
            };
        }

        private InterceptCandidate? BuildAirBasedCandidate(DroneGroup threat,
            FireUnit unit, AerosolType ammoType, AmmunitionSpec ammo,
            (float radius, float expTime) ammoEff, CombatScene env)
        {
            var mid = ThreatMidpoint(threat);
            float releaseAlt = unit.ReleaseAltitude > 0 ? unit.ReleaseAltitude : (float)threat.Target.TypicalAltitude + 500f;
            float flightDist = Kinematics.Distance3D(
                unit.Position.X, unit.Position.Y, unit.Position.Z,
                mid.X, releaseAlt, mid.Z);
            float cruiseSpd = unit.CruiseSpeed > 0.1f ? unit.CruiseSpeed : 55f;
            float flightTime = flightDist / cruiseSpd;
            float fallTime = Kinematics.AirDropFallTime(releaseAlt, (float)threat.Target.TypicalAltitude);
            float totalTime = flightTime + fallTime;

            float interceptTime = threat.ArrivalTime;
            if (totalTime > interceptTime * 1.5f) return null;

            float avgSpeed = (float)threat.Target.TypicalSpeed / 3.6f;
            float neededExposure = ammoType == AerosolType.ActiveMaterial ? 2f : 6f;
            float actualExposure = ammoEff.radius * 2f / avgSpeed;
            float prob = Math.Min(0.95f, actualExposure / neededExposure);

            return new InterceptCandidate
            {
                Unit = unit,
                AmmoType = ammoType,
                EarliestInterceptTime = interceptTime,
                CoverageDuration = ammoEff.radius * 2f,
                KillProbability = prob,
                FlightTime = totalTime,
                ShellFlightTime = fallTime,
            };
        }

        // ═══════════════════════════════════════════════
        // 弹药计算（使用 AmmunitionSpec + 环境参数）
        // ═══════════════════════════════════════════════

        private (float effectiveRadius, float expansionTime) ComputeEffectiveRadius(
            DroneGroup threat, AmmunitionSpec ammo, CombatScene env)
        {
            float totalFlightTime = threat.ArrivalTime * 2f;
            float halfTime = totalFlightTime / 2f;
            float windSpeed = (float)env.WindSpeed;
            var weather = (WeatherType)env.WeatherType;
            float avgSpeed = (float)threat.Target.TypicalSpeed / 3.6f;

            // Phase 1 初始半径（基于爆发药 TNT 当量）
            float r0 = 3.3f * (float)Math.Pow(Math.Max(0.01, (float)ammo.BurstChargeKg), 0.32);
            float k = (float)ammo.TurbulentExpansionK;
            float maxDur = (float)ammo.MaxDuration;

            // Phase 2 湍流膨胀后的半径
            float phase2Time = Math.Min(halfTime, 30f);
            float rPhase2 = r0 + k * (float)Math.Sqrt(Math.Max(0, phase2Time));

            float expansionTime = (float)Math.Pow((rPhase2 - r0) / Math.Max(k, 0.01f), 2);
            float effectiveR = rPhase2;

            // Phase 3 高斯扩散
            if (halfTime > 30f)
            {
                float x = Math.Max(1f, windSpeed * (halfTime - 30f));
                var cls = Kinematics.GetStabilityClass(weather, windSpeed);
                float sY = Kinematics.SigmaY(cls, x);
                float sZ = Kinematics.SigmaZ(cls, x);
                float peakC = Kinematics.GaussianPeakConcentration((float)ammo.SourceStrength, sY, sZ);
                float threshold = (float)ammo.EffectiveConcentration;
                if (peakC > threshold)
                {
                    float sigma = (sY + sZ) / 2f;
                    effectiveR = rPhase2 + sigma * (float)Math.Sqrt(2f * Math.Log(peakC / threshold));
                }
            }

            return (effectiveR, expansionTime);
        }

        private int CalcRoundsNeeded(DroneGroup threat, AmmunitionSpec? ammo,
            CombatScene env, bool isAirBased)
        {
            if (ammo == null) return 1;

            float avgSpeed = (float)threat.Target.TypicalSpeed / 3.6f;
            var (effectiveR, _) = ComputeEffectiveRadius(threat, ammo, env);
            float spacing = effectiveR * 1.5f;

            var aerosolType = (AerosolType)ammo.AerosolType;
            float neededExposure = aerosolType == AerosolType.ActiveMaterial ? 2f : 6f;
            float requiredCoverage = neededExposure * avgSpeed;

            return Math.Max(1,
                (int)Math.Ceiling((requiredCoverage - 2f * effectiveR) / spacing) + 1);
        }

        private float ComputeInterceptProbability(DroneGroup threat,
            AmmunitionSpec? ammo, int rounds, CombatScene env)
        {
            if (ammo == null) return 0f;

            float avgSpeed = (float)threat.Target.TypicalSpeed / 3.6f;
            var (effectiveR, _) = ComputeEffectiveRadius(threat, ammo, env);
            float spacing = effectiveR * 1.5f;
            float actualCoverage = spacing * (rounds - 1) + 2f * effectiveR;
            float actualExposure = actualCoverage / avgSpeed;

            var aerosolType = (AerosolType)ammo.AerosolType;
            float neededExposure = aerosolType == AerosolType.ActiveMaterial ? 2f : 6f;

            return Math.Min(0.95f, actualExposure / neededExposure);
        }

        // ═══════════════════════════════════════════════
        // 发射事件生成（真实物理）
        // ═══════════════════════════════════════════════

        private List<FireEvent> GenerateFireEvents(DroneGroup threat, FireUnit unit,
            AerosolType ammoType, int rounds, AmmunitionSpec? ammo, CombatScene env)
        {
            var events = new List<FireEvent>();
            if (ammo == null) return events;

            var mid = ThreatMidpoint(threat);
            var (effectiveR, expansionTime) = ComputeEffectiveRadius(threat, ammo, env);
            float spacing = effectiveR * 1.5f;

            // 推荐时机：威胁到达中点时云团应已形成
            float recommendedTiming = threat.ArrivalTime - expansionTime;
            if (recommendedTiming < 0.1f) recommendedTiming = 0.1f;

            for (int i = 0; i < rounds; i++)
            {
                float offset = (i - (rounds - 1) / 2f) * spacing;
                float tx = mid.X + offset;
                float tz = mid.Z;
                float fireTime;

                if (unit.Type == PlatformType.AirBased)
                {
                    float releaseAlt = unit.ReleaseAltitude > 0 ? unit.ReleaseAltitude : (float)threat.Target.TypicalAltitude + 500f;
                    float flightDist = Kinematics.Distance3D(
                        unit.Position.X, unit.Position.Y, unit.Position.Z,
                        tx, releaseAlt, tz);
                    float cruiseSpd = unit.CruiseSpeed > 0.1f ? unit.CruiseSpeed : 55f;
                    float flightTime = flightDist / cruiseSpd;
                    float fallTime = Kinematics.AirDropFallTime(releaseAlt, (float)threat.Target.TypicalAltitude);
                    fireTime = recommendedTiming - flightTime - fallTime;
                }
                else
                {
                    float dx = tx - unit.Position.X;
                    float dz = tz - unit.Position.Z;
                    float dist = (float)Math.Sqrt(dx * dx + dz * dz);
                    float shellTime = dist / (unit.MuzzleVelocity > 0.1f ? unit.MuzzleVelocity : 800f);
                    fireTime = recommendedTiming - shellTime;
                }

                if (fireTime < 0.1f) fireTime = 0.1f;

                events.Add(new FireEvent
                {
                    FireTime = fireTime,
                    PlatformIndex = i % rounds,
                    TargetX = tx,
                    TargetY = mid.Y,
                    TargetZ = tz,
                    MuzzleVelocity = unit.MuzzleVelocity,
                });
            }

            return events;
        }

        // ═══════════════════════════════════════════════
        // Step 5: 临界方案（概率阈值 50%）
        // ═══════════════════════════════════════════════

        private DefensePlan DeriveCritical(DefensePlan best)
        {
            var critical = new DefensePlan
            {
                ThreatsEngaged = best.ThreatsEngaged,
                ThreatsUnengaged = best.ThreatsUnengaged,
            };

            foreach (var assignment in best.Assignments)
            {
                int rounds = assignment.RoundsFired;
                while (rounds > 1)
                {
                    // 简化：弹药减半 → 概率减半
                    if ((float)rounds / assignment.RoundsFired < 0.5f) break;
                    rounds--;
                }

                var reduced = new UnitAssignment
                {
                    FireUnitId = assignment.FireUnitId,
                    DroneGroupId = assignment.DroneGroupId,
                    AmmoType = assignment.AmmoType,
                    RoundsFired = rounds,
                    FirstFireTime = assignment.FirstFireTime,
                    FireEvents = assignment.FireEvents.Take(rounds).ToList(),
                };
                critical.Assignments.Add(reduced);
                critical.MergedSchedule.AddRange(reduced.FireEvents);
            }

            critical.MergedSchedule.Sort((a, b) => a.FireTime.CompareTo(b.FireTime));
            critical.OverallProbability = 0.5f;
            critical.Summary = $"临界方案：刚好满足 50% 拦截概率";
            return critical;
        }

        // ═══════════════════════════════════════════════
        // 辅助
        // ═══════════════════════════════════════════════

        private static Vector3 ThreatMidpoint(DroneGroup threat)
        {
            if (threat.Waypoints.Count < 2)
                return new Vector3(0, (float)threat.Target.TypicalAltitude, 0);
            var s = threat.Waypoints[0];
            var e = threat.Waypoints[^1];
            return new Vector3(
                (float)(s.PosX + e.PosX) / 2f,
                (float)(s.PosY + e.PosY) / 2f,
                (float)(s.PosZ + e.PosZ) / 2f);
        }
    }
}