using System;
using System.Collections.Generic;
using System.Threading;
using System.Linq;
using System.Diagnostics;
using ThreatSource.Missile;
using ThreatSource.Simulation;
using ThreatSource.Utils;
using ThreatSource.Jamming;
using ThreatSource.Sensor;
using ThreatSource.Target;
using ThreatSource.Guidance;
using ThreatSource.Indicator;

namespace ThreatSource.Tools.MissileSimulation
{
    /// <summary>
    /// 综合导弹模拟器 - 支持6种不同类型的导弹模拟
    /// </summary>
    public class ComprehensiveMissileSimulator
    {
        // 定义仿真结束事件
        public event EventHandler? SimulationEnded;
        
        private readonly ISimulationManager simulationManager;
        private readonly Dictionary<string, SimulationElement> missiles;
        private readonly Dictionary<string, SimulationElement> targets;
        private readonly Dictionary<string, SimulationElement> sensors;
        private Dictionary<string, bool> missileActiveStatus;
        private readonly double timeStep = 0.01; // 时间步长，单位：秒

        /// <summary>
        /// 初始化综合导弹模拟器
        /// </summary>
        public ComprehensiveMissileSimulator()
        {
            simulationManager = new SimulationManager();
            missiles = new Dictionary<string, SimulationElement>();
            targets = new Dictionary<string, SimulationElement>();
            sensors = new Dictionary<string, SimulationElement>();
            missileActiveStatus = new Dictionary<string, bool>();
            InitializeSimulation();
        }

        /// <summary>
        /// 初始化仿真环境
        /// </summary>
        private void InitializeSimulation()
        {
            // 添加目标（坦克）
            AddTarget("Tank_1", new Vector3D(0, 0, 0));

            // 添加各种类型的导弹
            AddLaserSemiActiveMissile();
            AddLaserBeamRiderMissile();
            AddTerminalSensitiveMissile();
            AddInfraredCommandMissile();
            AddInfraredImagingMissile();
            AddMillimeterWaveMissile();

            // 添加各种传感器和指示器
            AddSensorsAndDesignators();

            // 初始化所有导弹的激活状态为false
            foreach (var missile in missiles.Keys)
            {
                missileActiveStatus[missile] = false;
                missiles[missile].Activate(); // 激活导弹，但不会更新状态
            }
        }

        /// <summary>
        /// 添加目标
        /// </summary>
        private void AddTarget(string targetId, Vector3D position)
        {
            var target = new Tank(targetId, position, 0, simulationManager)
            {
                Position = position
            };
            targets[targetId] = target;
            simulationManager.RegisterEntity(targetId, target);
            target.Activate();  // 添加这行，激活目标
            Console.WriteLine($"添加目标 {targetId}，位置：{position}");
        }

        /// <summary>
        /// 添加激光半主动制导导弹
        /// </summary>
        private void AddLaserSemiActiveMissile()
        {
            var properties = new MissileProperties
            {
                Id = "LSGM_1",
                Mass = 50,
                ExplosionRadius = 5,
                MaxSpeed = 800,
                MaxFlightTime = 10,
                MaxFlightDistance = 5000,
                MaxAcceleration = 400,
                InitialPosition = new Vector3D(2000, 100, 100),
                InitialSpeed = 700,
                InitialOrientation = new Orientation(Math.PI, -0.05, 0),
                ProportionalNavigationCoefficient = 3,
                SelfDestructHeight = 0,
                Type = MissileType.LaserSemiActiveGuidance
            };

            var missile = new LaserSemiActiveGuidedMissile(properties, simulationManager);
            missiles["LSGM_1"] = missile;
            simulationManager.RegisterEntity("LSGM_1", missile);
            Console.WriteLine($"注册激光半主动导弹 LSGM_1");
        }

        /// <summary>
        /// 添加激光驾束制导导弹
        /// </summary>
        private void AddLaserBeamRiderMissile()
        {
            var properties = new MissileProperties
            {
                Id = "LBRM_1",
                Mass = 50,
                ExplosionRadius = 5,
                MaxSpeed = 400,
                MaxFlightTime = 10,
                MaxFlightDistance = 3000,
                MaxAcceleration = 400,
                InitialPosition = new Vector3D(2000, 10, 100),
                InitialSpeed = 300,
                InitialOrientation = new Orientation(Math.PI, 0.0, 0.0),
                ProportionalNavigationCoefficient = 3,
                SelfDestructHeight = 0,
                Type = MissileType.LaserBeamRiderGuidance
            };

            var missile = new LaserBeamRiderMissile(properties, simulationManager);
            missiles["LBRM_1"] = missile;
            simulationManager.RegisterEntity("LBRM_1", missile);
            Console.WriteLine($"注册激光束骑导弹 LBRM_1");
        }

        /// <summary>
        /// 添加末敏弹
        /// </summary>
        private void AddTerminalSensitiveMissile()
        {
            var properties = new MissileProperties
            {
                Id = "TSM_1",
                Mass = 50,
                ExplosionRadius = 5,
                MaxSpeed = 1000,
                MaxFlightTime = 100,
                MaxFlightDistance = 5000,
                MaxAcceleration = 200,
                InitialPosition = new Vector3D(3000, 0, 0),
                InitialSpeed = 800,
                InitialOrientation = new Orientation(Math.PI, 0, 0),
                SelfDestructHeight = 0,
                Type = MissileType.TerminalSensitiveMissile
            };

            var submunitionProperties = new MissileProperties
            {
                MaxSpeed = 2000,
                MaxFlightTime = 60,
                MaxFlightDistance = 2000,
                MaxAcceleration = 300,
                ProportionalNavigationCoefficient = 4,
                Mass = 10,
                ExplosionRadius = 5,
                HitProbability = 0.9,
                SelfDestructHeight = 20,
                Type = MissileType.TerminalSensitiveSubmunition
            };

            var missile = new TerminalSensitiveMissile("Tank_1", properties, submunitionProperties, 1, simulationManager);
            missiles["TSM_1"] = missile;
            simulationManager.RegisterEntity("TSM_1", missile);
            Console.WriteLine($"注册末敏导弹 TSM_1");
        }

        /// <summary>
        /// 添加红外指令制导导弹
        /// </summary>
        private void AddInfraredCommandMissile()
        {
            var properties = new MissileProperties
            {
                Id = "ICGM_1",
                Mass = 50,
                ExplosionRadius = 5,
                MaxSpeed = 400,
                MaxFlightTime = 60,
                MaxFlightDistance = 2100,
                MaxAcceleration = 100,
                InitialPosition = new Vector3D(2000, 10, 100),
                InitialSpeed = 300,
                InitialOrientation = new Orientation(Math.PI, 0.0, 0),
                ProportionalNavigationCoefficient = 3,
                SelfDestructHeight = 0,
                Type = MissileType.InfraredCommandGuidance
            };

            var missile = new InfraredCommandGuidedMissile(properties, simulationManager);
            missiles["ICGM_1"] = missile;
            simulationManager.RegisterEntity("ICGM_1", missile);
            Console.WriteLine($"注册红外指令导弹 ICGM_1");
        }

        /// <summary>
        /// 添加红外成像末制导导弹
        /// </summary>
        private void AddInfraredImagingMissile()
        {
            var properties = new MissileProperties
            {
                Id = "ITGM_1",
                Mass = 50,
                ExplosionRadius = 5,
                MaxSpeed = 400,
                MaxFlightTime = 60,
                MaxFlightDistance = 5000,
                MaxAcceleration = 50,
                InitialPosition = new Vector3D(2000, 20, 100),
                InitialSpeed = 300,
                InitialOrientation = new Orientation(Math.PI, 0.0, 0),
                SelfDestructHeight = 0,
                ProportionalNavigationCoefficient = 3,
                Type = MissileType.InfraredImagingTerminalGuidance
            };

            var missile = new InfraredImagingTerminalGuidedMissile(properties, simulationManager);
            missiles["ITGM_1"] = missile;
            simulationManager.RegisterEntity("ITGM_1", missile);
            Console.WriteLine($"注册红外成像导弹 ITGM_1");
        }

        /// <summary>
        /// 添加毫米波末制导导弹
        /// </summary>
        private void AddMillimeterWaveMissile()
        {
            var properties = new MissileProperties
            {
                Id = "MMWG_1",
                Mass = 50,
                ExplosionRadius = 5,
                MaxSpeed = 400,
                MaxFlightTime = 60,
                MaxFlightDistance = 5000,
                MaxAcceleration = 50,
                InitialPosition = new Vector3D(2000, 200, 100),
                InitialSpeed = 300,
                InitialOrientation = new Orientation(Math.PI, 0.0, 0),
                SelfDestructHeight = 0,
                ProportionalNavigationCoefficient = 3,
                Type = MissileType.MillimeterWaveTerminalGuidance
            };

            var missile = new MillimeterWaveTerminalGuidedMissile(properties, simulationManager);
            missiles["MMWG_1"] = missile;
            simulationManager.RegisterEntity("MMWG_1", missile);
            Console.WriteLine($"注册毫米波导弹 MMWG_1");
        }

        /// <summary>
        /// 添加传感器和指示器
        /// </summary>
        private void AddSensorsAndDesignators()
        {
            // 添加激光目标指示器
            var laserDesignator = new LaserDesignator(
                "LD_1",
                "Tank_1",
                "LSGM_1",
                0,
                new LaserDesignatorConfig
                {
                    Id = "LD_1",
                    InitialPosition = new Vector3D(2000, 150, 100),
                    LaserPower = 1000,
                    LaserDivergenceAngle = 0.001
                },
                simulationManager
            );
            sensors["LD_1"] = laserDesignator;
            simulationManager.RegisterEntity("LD_1", laserDesignator);
            Console.WriteLine("注册激光目标指示器 LD_1");

            // 添加激光驾束仪
            var laserBeamRider = new LaserBeamRider(
                "LBR_1",
                "LBRM_1",
                "Tank_1",
                0,
                new LaserBeamRiderConfig
                {
                    Id = "LBR_1",
                    InitialPosition = new Vector3D(2000, 10, 100),
                    LaserPower = 1000,
                    ControlFieldDiameter = 6
                },
                simulationManager
            );
            sensors["LBR_1"] = laserBeamRider;
            simulationManager.RegisterEntity("LBR_1", laserBeamRider);
            Console.WriteLine("注册激光驾束仪 LBR_1");

            // 添加红外测角仪
            var infraredTracker = new InfraredTracker(
                "IT_1",
                "Tank_1",
                new InfraredTrackerConfig
                {
                    Id = "IT_1",
                    InitialPosition = new Vector3D(2000, 0, 100),
                    InitialOrientation = new Orientation(Math.PI, 0, 0),
                    MaxTrackingRange = 10000,
                    FieldOfView = Math.PI / 4,
                    AngleMeasurementAccuracy = 0.0005,
                    UpdateFrequency = 100
                },
                simulationManager
            );
            sensors["IT_1"] = infraredTracker;
            simulationManager.RegisterEntity("IT_1", infraredTracker);
            Console.WriteLine("注册红外测角仪 IT_1");
        }

        /// <summary>
        /// 选择要激活的导弹
        /// </summary>
        public void SelectMissile(string missileId)
        {
            if (!missiles.ContainsKey(missileId))
            {
                Console.WriteLine($"错误：找不到导弹 {missileId}");
                return;
            }

            // 先停用所有导弹和传感器
            foreach (var id in missiles.Keys)
            {
                missileActiveStatus[id] = false;
                missiles[id].Deactivate();
            }
            foreach (var sensor in sensors.Values)
            {
                sensor.Deactivate();
            }

            // 激活选中的导弹
            missileActiveStatus[missileId] = true;
            missiles[missileId].Activate();
            Console.WriteLine($"已选择导弹：{missileId}");

            // 确保所有目标都处于激活状态
            foreach (var target in targets.Values)
            {
                target.Activate();
                Console.WriteLine($"确保目标 {target.Id} 处于激活状态");
            }

            // 激活相关的传感器和指示器
            ActivateRelatedSensors(missileId);

            // 打印所有注册的组件
            PrintSimulationRegisteredComponents();
        }

        /// <summary>
        /// 激活与导弹相关的传感器和指示器
        /// </summary>
        private void ActivateRelatedSensors(string missileId)
        {
            // 根据导弹类型激活相应的传感器
            switch (missileId)
            {
                case "LSGM_1": // 激光半主动制导导弹
                    if (sensors.ContainsKey("LD_1"))
                    {
                        sensors["LD_1"].Activate();
                    }
                    break;
                case "LBRM_1": // 激光驾束制导导弹
                    if (sensors.ContainsKey("LBR_1"))
                    {
                        sensors["LBR_1"].Activate();
                    }
                    break;
                case "ICGM_1": // 红外指令制导导弹
                case "ITGM_1": // 红外成像末制导导弹
                    if (sensors.ContainsKey("IT_1"))
                    {
                        sensors["IT_1"].Activate();
                    }
                    break;
                case "TSM_1": // 末敏弹
                case "MMWG_1": // 毫米波末制导导弹
                    // 这些导弹使用自身的传感器系统
                    break;
            }
        }

        /// <summary>
        /// 应用干扰
        /// </summary>
        public void ApplyJamming(JammingType type, double power, double duration, Vector3D position)
        {
            var jammingParams = new JammingParameters
            {
                Type = type,
                Power = power,
                Duration = duration,
                Direction = new Vector3D(1, 0, 0)
            };

            foreach (var missile in missiles.Values)
            {
                if (missile is BaseMissile actualMissile)
                {
                    // 获取导弹内部的传感器
                    var infraredDetector = actualMissile.GetType().GetField("infraredDetector", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as InfraredDetector;
                    var radiometer = actualMissile.GetType().GetField("radiometer", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as MillimeterWaveRadiometer;
                    var rangefinder = actualMissile.GetType().GetField("rangefinder", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as LaserRangefinder;
                    var altimeter = actualMissile.GetType().GetField("altimeter", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as MillimeterWaveAltimeter;

                    switch (type)
                    {
                        case JammingType.Infrared:
                            infraredDetector?.ApplyJamming(jammingParams);
                            break;
                        case JammingType.MillimeterWave:
                            radiometer?.ApplyJamming(jammingParams);
                            altimeter?.ApplyJamming(jammingParams);
                            break;
                        case JammingType.Laser:
                            rangefinder?.ApplyJamming(jammingParams);
                            break;
                    }
                }
            }
        }

        /// <summary>
        /// 清除干扰
        /// </summary>
        public void ClearJamming(JammingType type)
        {
            var jammingParams = new JammingParameters
            {
                Type = type,
                Power = 0,
                Duration = 0,
                Direction = new Vector3D(1, 0, 0)
            };

            foreach (var missile in missiles.Values)
            {
                if (missile is BaseMissile actualMissile)
                {
                    // 获取导弹内部的传感器
                    var infraredDetector = actualMissile.GetType().GetField("infraredDetector", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as InfraredDetector;
                    var radiometer = actualMissile.GetType().GetField("radiometer", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as MillimeterWaveRadiometer;
                    var rangefinder = actualMissile.GetType().GetField("rangefinder", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as LaserRangefinder;
                    var altimeter = actualMissile.GetType().GetField("altimeter", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(actualMissile) as MillimeterWaveAltimeter;

                    switch (type)
                    {
                        case JammingType.Infrared:
                            infraredDetector?.ClearJamming(type);
                            break;
                        case JammingType.MillimeterWave:
                            radiometer?.ClearJamming(type);
                            altimeter?.ClearJamming(type);
                            break;
                        case JammingType.Laser:
                            rangefinder?.ClearJamming(type);
                            break;
                    }
                }
            }
        }

        /// <summary>
        /// 开始模拟
        /// </summary>
        public void Start()
        {
            Console.WriteLine("开始综合导弹模拟...");

            // 确保所有激活的导弹和传感器都处于正确状态
            foreach (var missile in missiles.Values)
            {
                if (missileActiveStatus[missile.Id])
                {
                    missile.Activate();
                }
            }

            // 确保所有目标都处于激活状态
            foreach (var target in targets.Values)
            {
                target.Activate();
                Console.WriteLine($"激活目标：{target.Id}");
            }

            // 打印仿真开始前的组件状态
            PrintSimulationRegisteredComponents();

            // 启动仿真系统
            simulationManager.StartSimulation(timeStep);

            while (simulationManager.State == SimulationState.Running)
            {
                // 让仿真管理器统一处理所有实体的更新
                simulationManager.Update(timeStep);

                // 检查是否还有活跃的导弹
                var activeMissiles = simulationManager.GetEntitiesByType<BaseMissile>()
                    .Where(m => m.IsActive);
                    
                if (!activeMissiles.Any())
                {
                    simulationManager.StopSimulation();
                    SimulationEnded?.Invoke(this, EventArgs.Empty);
                    ResetSimulation();
                    break;
                }

                // 打印状态
                PrintSimulationStatus();

                Thread.Sleep((int)(timeStep * 1000));
            }
        }

        /// <summary>
        /// 打印仿真状态
        /// </summary>
        private void PrintSimulationStatus()
        {
            // 打印所有活跃导弹的状态
            var activeMissiles = simulationManager.GetEntitiesByType<BaseMissile>()
                .Where(m => m.IsActive);
                
            foreach (var missile in activeMissiles)
            {
                Console.WriteLine("\n========== 导弹状态 ==========");
                Console.WriteLine(missile.GetStatus());
            }

            // 打印目标状态
            foreach (var target in targets.Values)
            {
                Console.WriteLine("\n========== 目标状态 ==========");
                Console.WriteLine($"目标ID: {target.Id}");
                Console.WriteLine($"位置: {target.Position}");
                if (target is Tank tank)
                {
                    Console.WriteLine($"朝向: {tank.Orientation}");
                }
            }

            // 打印激活的传感器状态
            foreach (var sensor in sensors.Values.Where(s => s.IsActive))
            {
                Console.WriteLine("\n========== 传感器状态 ==========");
                Console.WriteLine(sensor.GetStatus());
            }
        }

        /// <summary>
        /// 停止模拟
        /// </summary>
        public void Stop()
        {
            simulationManager.StopSimulation();
            Console.WriteLine("模拟结束");
        }

        /// <summary>
        /// 暂停模拟
        /// </summary>
        public void Pause()
        {
            simulationManager.PauseSimulation();
            Console.WriteLine("模拟暂停");
        }

        /// <summary>
        /// 恢复模拟
        /// </summary>
        public void Resume()
        {
            simulationManager.ResumeSimulation();
            Console.WriteLine("模拟恢复");
        }

        /// <summary>
        /// 重置仿真状态
        /// </summary>
        public void ResetSimulation()
        {
            // 获取所有活跃的导弹
            var activeMissiles = simulationManager.GetEntitiesByType<BaseMissile>();
            foreach (var missile in activeMissiles)
            {
                // 获取导弹的初始属性
                var properties = missile.GetType().GetField("properties", 
                    System.Reflection.BindingFlags.NonPublic | 
                    System.Reflection.BindingFlags.Instance)?.GetValue(missile) as MissileProperties;
                
                if (properties != null)
                {
                    // 重置导弹位置和状态
                    missile.Position = properties.InitialPosition;
                    missile.Velocity = Vector3D.Zero;
                }
                missile.Deactivate();
            }

            // 重置所有传感器状态
            var activeSensors = simulationManager.GetEntitiesByType<SimulationElement>()
                .Where(e => sensors.ContainsValue(e));
            foreach (var sensor in activeSensors)
            {
                sensor.Deactivate();
            }

            // 重置所有目标状态
            var activeTargets = simulationManager.GetEntitiesByType<Tank>();
            foreach (var target in activeTargets)
            {
                var initialPosition = target.Position;
                target.Deactivate();
                target.Position = initialPosition;
                target.Activate();
            }

            // 重置导弹激活状态
            missileActiveStatus.Clear();
            foreach (var missile in missiles.Values)
            {
                missileActiveStatus[missile.Id] = false;
            }

            Console.WriteLine("仿真状态已重置");
        }

        /// <summary>
        /// 打印所有注册到仿真管理器中的组件
        /// </summary>
        public void PrintSimulationRegisteredComponents()
        {
            Console.WriteLine("\n========== 仿真管理器中的注册组件 ==========");
            var allEntities = simulationManager.GetAllEntities();
            foreach (var entity in allEntities)
            {
                if (entity is SimulationElement simElement)
                {
                    Console.WriteLine($"{simElement.Id} ({entity.GetType().Name})");
                }
                else
                {
                    Console.WriteLine($"未知组件 ({entity.GetType().Name})");
                }
            }
            Console.WriteLine($"总计: {allEntities.Count()} 个组件");
        }

        /// <summary>
        /// 获取当前活动的传感器列表
        /// </summary>
        public (string Id, string Name, bool IsActive)[] GetActiveSensors()
        {
            return sensors.Select(s => (
                s.Value.Id,
                GetSensorDisplayName(s.Value),
                s.Value.IsActive
            )).ToArray();
        }
        
        /// <summary>
        /// 获取传感器的显示名称
        /// </summary>
        private string GetSensorDisplayName(SimulationElement sensor)
        {
            return sensor switch
            {
                LaserDesignator _ => "激光目标指示器",
                LaserBeamRider _ => "激光驾束仪",
                InfraredTracker _ => "红外测角仪",
                _ => sensor.Id
            };
        }
        
        /// <summary>
        /// 切换传感器的激活状态
        /// </summary>
        public void ToggleSensor(string sensorId)
        {
            if (sensors.TryGetValue(sensorId, out var sensor))
            {
                if (sensor.IsActive)
                    sensor.Deactivate();
                else
                    sensor.Activate();
                
                Console.WriteLine($"传感器 {GetSensorDisplayName(sensor)} 已{(sensor.IsActive ? "激活" : "停用")}");
            }
        }
    }
}