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;
using ThreatSource.Data;
using AirTransmission;

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

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

        /// <summary>
        /// 初始化仿真环境
        /// </summary>
        private void InitializeSimulation()
        {
            // 添加天气
            AddWeathers();

            // 添加目标（坦克）
            AddTankTarget();

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

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

            
        }

        /// <summary>
        /// 添加天气
        /// </summary>
        private void AddWeathers()
        {
            // 创建雨天天气并设置为当前天气
            var rainWeather = _threatSourceFactory.CreateWeather("sunny");
            simulationManager.SetWeather(rainWeather);
            Console.WriteLine("已添加并设置晴天天气环境");
        }

        /// <summary>
        /// 添加目标
        /// </summary>
        private void AddTankTarget()
        {
            var launchParams = new InitialMotionParameters
            {
                Position = new Vector3D(0, 0, 0),
                Orientation = new Orientation(Math.PI, 0.0, 0.0),
                InitialSpeed = 0
            };
            string targetId = "Tank_1";
            var target = _threatSourceFactory.CreateTarget(targetId, "mbt_001", launchParams);
            targets[targetId] = target;
            simulationManager.RegisterEntity(targetId, target);
            Console.WriteLine($"添加目标 {targetId}，位置：{launchParams.Position}");

            // 添加诱偏目标
            Tank tank = (Tank)target;
            tank.LaunchLaserDecoy(new Vector3D(0, 0, 1), 50, 25, 20);
        }

        /// <summary>
        /// 添加激光半主动制导导弹
        /// </summary>
        private void AddLaserSemiActiveMissile()
        {
            var launchParams = new InitialMotionParameters
            {
                Position = new Vector3D(2000, 1, 100),
                Orientation = new Orientation(Math.PI, 0.05, 0),
                InitialSpeed = 700
            };
            string missileId = "LSGM_1";
            var missile = _threatSourceFactory.CreateMissile(missileId, "lsgm_001", "Tank_1", launchParams);
            missiles[missileId] = missile;
            simulationManager.RegisterEntity(missileId, missile);
            Console.WriteLine($"注册激光半主动制导导弹 {missileId}");
        }

        /// <summary>
        /// 添加激光驾束制导导弹
        /// </summary>
        private void AddLaserBeamRiderMissile()
        {
            var launchParams = new InitialMotionParameters
            {
                Position = new Vector3D(2000, 10, 100),
                Orientation = new Orientation(Math.PI, 0.0, 0.0),
                InitialSpeed = 300
            };
            string missileId = "LBRM_1";
            var missile = _threatSourceFactory.CreateMissile(missileId, "hj10", "Tank_1", launchParams);
            missiles[missileId] = missile;
            simulationManager.RegisterEntity(missileId, missile);
            Console.WriteLine($"注册激光驾束制导导弹 {missileId}");
        }

        /// <summary>
        /// 添加末敏弹
        /// </summary>
        private void AddTerminalSensitiveMissile()
        {
            var launchParams = new InitialMotionParameters
            {
                Position = new Vector3D(3000, 0, 100),
                Orientation = new Orientation(Math.PI, 0, 0),
                InitialSpeed = 800
            };

            string missileId = "TSM_1";
            var missile = _threatSourceFactory.CreateMissile(missileId, "tsm_001", "Tank_1", launchParams);

            missiles[missileId] = missile;
            simulationManager.RegisterEntity(missileId, missile);
            Console.WriteLine($"注册末敏弹 {missileId}");
        }

        /// <summary>
        /// 添加红外指令制导导弹
        /// </summary>
        private void AddInfraredCommandMissile()
        {
            var launchParams = new InitialMotionParameters
            {
                Position = new Vector3D(2000, 10, 100),
                Orientation = new Orientation(Math.PI, 0.0, 0),
                InitialSpeed = 300
            };

            string missileId = "ICGM_1";
            var missile = _threatSourceFactory.CreateMissile(missileId, "irc_001", "Tank_1", launchParams);
            missiles[missileId] = missile;
            simulationManager.RegisterEntity(missileId, missile);
            Console.WriteLine($"注册红外指令制导导弹 {missileId}");
        }

        /// <summary>
        /// 添加红外成像末制导导弹
        /// </summary>
        private void AddInfraredImagingMissile()
        {
            var launchParams = new InitialMotionParameters
            {
                Position = new Vector3D(2000, 20, 50),
                Orientation = new Orientation(Math.PI, 0.0, 0),
                InitialSpeed = 300
            };
            string missileId = "ITGM_1";
            var missile = _threatSourceFactory.CreateMissile(missileId, "itg_001", "Tank_1", launchParams);
            missiles[missileId] = missile;
            simulationManager.RegisterEntity(missileId, missile);
            Console.WriteLine($"注册红外成像末制导导弹 {missileId}");
        }

        /// <summary>
        /// 添加毫米波末制导导弹
        /// </summary>
        private void AddMillimeterWaveMissile()
        {
            var launchParams = new InitialMotionParameters
            {
                Position = new Vector3D(3000, 20, 100),
                Orientation = new Orientation(Math.PI, 0.0, 0),
                InitialSpeed = 300
            };  
            string missileId = "MMWG_1";
            var missile = _threatSourceFactory.CreateMissile(missileId, "mmw_001", "Tank_1", launchParams);
            missiles[missileId] = missile;
            simulationManager.RegisterEntity(missileId, missile);
            Console.WriteLine($"注册毫米波末制导导弹 {missileId}");
        }

        /// <summary>
        /// 添加传感器和指示器
        /// </summary>
        private void AddSensorsAndDesignators()
        {
            // 添加激光目标指示器
            string laserDesignatorId = "LD_1";
            var laserDesignatorLaunchParams = new InitialMotionParameters
            {
                Position = new Vector3D(2100, 10, 100),
                Orientation = new Orientation(Math.PI, 0, 0),
                InitialSpeed = 0
            };
            var laserDesignator = _threatSourceFactory.CreateIndicator(laserDesignatorId, "ld_001", "Tank_1", "LSGM_1", laserDesignatorLaunchParams);
            indicators[laserDesignatorId] = (SimulationElement)laserDesignator;
            simulationManager.RegisterEntity(laserDesignatorId, laserDesignator);
            Console.WriteLine($"注册激光目标指示器 {laserDesignatorId}");

            // 添加激光驾束仪
            string laserBeamRiderId = "LBR_1";
            var laserBeamRiderLaunchParams = new InitialMotionParameters
            {
                Position = new Vector3D(2100, 10, 100),
                Orientation = new Orientation(Math.PI, 0, 0),
                InitialSpeed = 0
            };
            var laserBeamRider = _threatSourceFactory.CreateIndicator(laserBeamRiderId, "br_001", "Tank_1", "LBRM_1", laserBeamRiderLaunchParams);
            indicators[laserBeamRiderId] = (SimulationElement)laserBeamRider;
            simulationManager.RegisterEntity(laserBeamRiderId, laserBeamRider);
            Console.WriteLine($"注册激光驾束仪 {laserBeamRiderId}");

            // 添加红外测角仪
            string infraredTrackerId = "IT_1";
            var infraredTrackerLaunchParams = new InitialMotionParameters
            {
                Position = new Vector3D(2100, 10, 100),
                Orientation = new Orientation(Math.PI, 0, 0),
                InitialSpeed = 0
            };
            var infraredTracker = _threatSourceFactory.CreateIndicator(infraredTrackerId, "ir_001", "Tank_1", "ITGM_1", infraredTrackerLaunchParams);
            indicators[infraredTrackerId] = (SimulationElement)infraredTracker;
            simulationManager.RegisterEntity(infraredTrackerId, infraredTracker);
            Console.WriteLine($"注册红外测角仪 {infraredTrackerId}");
        }

        /// <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 indicator in indicators.Values)
            {
                indicator.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 (indicators.ContainsKey("LD_1"))
                    {
                        indicators["LD_1"].Activate();
                    }
                    break;
                case "LBRM_1": // 激光驾束制导导弹
                    if (indicators.ContainsKey("LBR_1"))
                    {
                        indicators["LBR_1"].Activate();
                    }
                    break;
                case "ICGM_1": // 红外指令制导导弹
                    if (indicators.ContainsKey("IT_1"))
                    {
                        indicators["IT_1"].Activate();
                    }
                    break;
                case "ITGM_1": // 红外成像末制导导弹
                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),
                SourcePosition = position
            };

            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),
                SourcePosition = new Vector3D(0, 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.Fire();
                }
            }

            // 打印仿真开始前的组件状态
            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 weather = simulationManager.CurrentWeather;
            if (weather != null)
            {
                Console.WriteLine("\n========== 天气状态 ==========");
                Console.WriteLine($"天气类型: {weather.Type}");
                Console.WriteLine($"温度: {weather.Temperature}°C");
                Console.WriteLine($"湿度: {weather.RelativeHumidity}%");
                Console.WriteLine($"能见度: {weather.Visibility}公里");
                Console.WriteLine($"风速: {weather.WindSpeed}米/秒");
                Console.WriteLine($"风向: {weather.WindDirection}°");
            }
            
            // 打印所有活跃导弹的状态
            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 indicators.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 launchParams = missile.GetType().GetField("launchParams", 
                    System.Reflection.BindingFlags.NonPublic | 
                    System.Reflection.BindingFlags.Instance)?.GetValue(missile) as InitialMotionParameters;
                
                if (launchParams != null)
                {
                    // 重置导弹位置和状态
                    missile.Position = launchParams.Position;
                    missile.Velocity = Vector3D.Zero;
                }
                missile.Deactivate();
            }

            // 重置所有传感器状态
            var activeSensors = simulationManager.GetEntitiesByType<SimulationElement>()
                .Where(e => indicators.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)[] GetActiveIndicators()
        {
            return indicators.Select(s => (
                s.Value.Id,
                GetIndicatorDisplayName(s.Value),
                s.Value.IsActive
            )).ToArray();
        }
        
        /// <summary>
        /// 获取传感器的显示名称
        /// </summary>
        private string GetIndicatorDisplayName(SimulationElement indicator)
        {
            return indicator switch
            {
                LaserDesignator _ => "激光目标指示器",
                LaserBeamRider _ => "激光驾束仪",
                InfraredTracker _ => "红外测角仪",
                _ => indicator.Id
            };
        }
        
        /// <summary>
        /// 切换传感器的激活状态
        /// </summary>
        public void ToggleIndicator(string indicatorId)
        {
            if (indicators.TryGetValue(indicatorId, out var indicator))
            {
                if (indicator.IsActive)
                    indicator.Deactivate();
                else
                    indicator.Activate();
                
                Console.WriteLine($"指示器 {GetIndicatorDisplayName(indicator)} 已{(indicator.IsActive ? "激活" : "停用")}");
            }
        }

        /// <summary>
        /// 切换天气
        /// </summary>
        /// <param name="weatherType">天气类型</param>
        public void SwitchWeather(string weatherType)
        {
            // 创建新的天气实例
            var newWeather = _threatSourceFactory.CreateWeather(weatherType);
            
            // 设置为当前天气
            simulationManager.SetWeather(newWeather);
            
            // 打印天气详情
            Console.WriteLine($"已切换到 {weatherType} 天气环境");
            Console.WriteLine($"温度: {newWeather.Temperature}°C");
            Console.WriteLine($"湿度: {newWeather.RelativeHumidity}%");
            Console.WriteLine($"能见度: {newWeather.Visibility}公里");
            Console.WriteLine($"风速: {newWeather.WindSpeed}米/秒");
            Console.WriteLine($"风向: {newWeather.WindDirection}°");
        }
    }
}