using ThreatSource.Utils;
using ThreatSource.Jammer;
using ThreatSource.Simulation;
using ThreatSource.Jammable;
using ThreatSource.Equipment;  
using System.Diagnostics;

namespace ThreatSource.Indicator
{
    /// <summary>
    /// 指示器抽象基类，实现IIndicator接口的基本功能
    /// </summary>
    /// <remarks>
    /// 该类提供了指示器的通用实现：
    /// - 位置和姿态管理
    /// - 激活状态控制
    /// - 干扰处理机制
    /// 是具体指示器类的实现基础
    /// </remarks>
    public abstract class BaseIndicator : SimulationElement, IIndicator, IJammable
    {
        /// <summary>
        /// 视觉遮挡阈值 (0.0 - 1.0)
        /// </summary>
        protected const double TargetObscurationThreshold = 0.8;

        /// <summary>
        /// 干扰处理组件
        /// </summary>
        protected readonly JammableComponent _jammingComponent;

        /// <summary>
        /// 获取目标是否被烟幕遮挡 (由任何烟幕引起)
        /// </summary>
        protected bool IsTargetObscured { get; private set; } = false;

        /// <summary>
        /// 最后一次成功获取的目标位置
        /// </summary>
        protected Vector3D? _lastKnownTargetPosition = null;

        /// <summary>
        /// 最后一次成功获取的目标朝向
        /// </summary>
        protected Orientation? _lastKnownTargetOrientation = null;

        /// <summary>
        /// 获取设备支持的干扰类型
        /// </summary>
        /// <remarks>
        /// 定义指示器可以被哪些类型的干扰影响
        /// 子类需要重写此属性以指定支持的干扰类型
        /// </remarks>
        public abstract IEnumerable<JammingType> SupportedJammingTypes { get; }

        /// <summary>
        /// 获取设备当前是否处于被干扰状态
        /// </summary>
        /// <remarks>
        /// true表示指示器当前受到干扰影响
        /// false表示指示器正常工作
        /// </remarks>
        public bool IsJammed => _jammingComponent.IsJammed;

        /// <summary>
        /// 获取或设置目标ID
        /// </summary>
        public string? TargetId { get; protected set; }

        /// <summary>
        /// 获取或设置导弹ID
        /// </summary>
        public string? MissileId { get; protected set; }

        /// <summary>
        /// 初始化指示器基类的新实例
        /// </summary>
        /// <param name="id">指示器ID</param>
        /// <param name="motionParameters">初始运动参数</param>
        /// <param name="manager">仿真管理器实例</param>
        /// <remarks>
        /// 构造过程：
        /// - 调用基类构造器
        /// - 初始化基本属性
        /// - 初始化干扰处理组件
        /// </remarks>
        protected BaseIndicator(string id, MotionParameters motionParameters, ISimulationManager manager)
            : base(id, motionParameters, manager)
        {
            _jammingComponent = new JammableComponent(
                positionProvider: () => base.Position
            );
            
            _jammingComponent.JammingApplied += HandleJammingApplied;
            _jammingComponent.JammingCleared += HandleJammingCleared;
        }

        /// <summary>
        /// 初始化干扰阈值和支持的干扰类型
        /// </summary>
        /// <param name="jammingResistanceThreshold">干扰抗性阈值，单位：瓦特</param>
        /// <param name="supportedTypes">支持的干扰类型</param>
        /// <remarks>
        /// 使用此方法初始化指示器的干扰处理参数：
        /// - 设置干扰抗性阈值
        /// - 配置支持的干扰类型
        /// 子类应在构造函数中调用此方法
        /// </remarks>
        protected void InitializeJamming(double jammingResistanceThreshold, IEnumerable<JammingType> supportedTypes)
        {
            _jammingComponent.LoadJammingConfigFromThreshold(jammingResistanceThreshold, supportedTypes);
        }

        /// <summary>
        /// 应用干扰
        /// </summary>
        /// <param name="parameters">干扰参数</param>
        /// <remarks>
        /// 处理对指示器的干扰影响
        /// 只有支持的干扰类型才会被处理
        /// </remarks>
        public virtual void ApplyJamming(JammingParameters parameters)
        {
            _jammingComponent.ApplyJamming(parameters);
        }

        /// <summary>
        /// 清除干扰
        /// </summary>
        /// <param name="parameters">干扰参数</param>
        /// <remarks>
        /// 移除特定类型的干扰影响
        /// 恢复指示器的正常工作状态
        /// </remarks>
        public virtual void ClearJamming(JammingParameters parameters)
        {
            _jammingComponent.ClearJamming(parameters);
        }

        /// <summary>
        /// 处理指示器被干扰的事件
        /// </summary>
        /// <param name="parameters">干扰参数</param>
        protected virtual void HandleJammingApplied(JammingParameters parameters)
        {
            // 如果是烟幕干扰，重新计算遮挡状态
            if (parameters.Type == JammingType.SmokeGrenade)
            {
                RecalculateObscurationStatus();
                Debug.WriteLine($"[BaseIndicator] 烟幕状态更新，IsTargetObscured: {IsTargetObscured}", "Jamming");
            }
            else // 其他干扰类型打印通用消息
            {
                 // 子类可以重写此方法以实现特定的干扰响应
                Debug.WriteLine($"[BaseIndicator] {this.GetType().Name} {Id} 受到 {parameters.Type} 类型干扰，功率：{parameters.Power}W", "Jamming");
            }
           
        }

        /// <summary>
        /// 处理指示器干扰被清除的事件
        /// </summary>
        /// <param name="parameters">干扰参数</param>
        protected virtual void HandleJammingCleared(JammingParameters parameters)
        {
             // 如果是烟幕干扰，重新计算遮挡状态
            if (parameters.Type == JammingType.SmokeGrenade)
            {
                RecalculateObscurationStatus();
                 Debug.WriteLine($"[BaseIndicator] 烟幕状态更新，IsTargetObscured: {IsTargetObscured}", "Jamming");
            }
            else // 其他干扰类型打印通用消息
            {
                 // 子类可以重写此方法以实现干扰清除后的特定行为
                Debug.WriteLine($"[BaseIndicator] {this.GetType().Name} {Id} {parameters.Type} 类型干扰已清除", "Jamming");
            }
        }

        /// <summary>
        /// 激活指示器 (基类统一处理干扰事件订阅)
        /// </summary>
        public override void Activate()
        {
             if (!IsActive)
             {
                IsActive = true;
                // 统一订阅 JammingEvent
                SimulationManager.SubscribeToEvent<JammingEvent>(HandleJammingEvent);
                // 子类仍需在此处订阅其他特定事件（如导弹热源事件）
             }
            base.Activate(); // 调用 SimulationElement 的基类 Activate
             // 子类需要在此之后调用 base.Activate() 并订阅烟幕事件 <--- 旧注释，移除或更新
             // 现在基类处理通用 JammingEvent，子类只需要处理非干扰事件
             RecalculateObscurationStatus(); // 激活时检查一次初始遮挡状态
        }

        /// <summary>
        /// 停用指示器 (基类统一处理干扰事件取消订阅)
        /// </summary>
        public override void Deactivate()
        {
             if (IsActive)
             {
                IsActive = false;
                 // 统一取消订阅 JammingEvent
                 SimulationManager.UnsubscribeFromEvent<JammingEvent>(HandleJammingEvent);
                  // 子类仍需在此处取消订阅其他特定事件
             }
            // 子类需要在此之前取消订阅烟幕事件 <--- 旧注释，移除或更新
            IsTargetObscured = false;
            // 重置最后目标状态
            _lastKnownTargetPosition = null;
            _lastKnownTargetOrientation = null;
            base.Deactivate(); // 调用 SimulationElement 的基类 Deactivate
        }

        /// <summary>
        /// 更新指示器状态
        /// </summary>
         public override void Update(double deltaTime)
        {
            _jammingComponent.UpdateJammingStatus(deltaTime); // 更新干扰状态（包括持续时间等）

            if (IsActive)
            {
                // 只有未被电子干扰时才更新指示器特定功能
                // 烟幕遮挡 (IsTargetObscured) 在 UpdateIndicator 内部处理
                if (!IsJammed) 
                {
                    UpdateIndicator(deltaTime);
                }
            }
        }

        /// <summary>
        /// 更新指示器特定功能
        /// </summary>
        /// <param name="deltaTime">时间步长，单位：秒</param>
        /// <remarks>
        /// 子类需要重写此方法以实现特定的更新逻辑
        /// 只有在未被干扰时才应执行正常的功能逻辑
        /// </remarks>
        protected virtual void UpdateIndicator(double deltaTime)
        {
            // 子类中实现具体的指示器更新逻辑
        }

        /// <summary>
        /// 获取指示器运行状态
        /// </summary>
        /// <returns>包含指示器完整状态信息的结构体</returns>
        /// <remarks>
        /// 子类需要重写此方法以提供完整的状态信息
        /// 包括位置、姿态、目标关联和干扰状态等
        /// </remarks>
        public abstract IndicatorRunningState GetRunningState();
        
        /// <summary>
        /// 获取指示器状态信息
        /// </summary>
        /// <returns>包含指示器状态信息的字符串</returns>
        public override string GetStatus()
        {
            return $"指示器 {Id} 当前状态: 上次目标位置: {_lastKnownTargetPosition}, 上次目标朝向: {_lastKnownTargetOrientation}";
        }

        /// <summary>
        /// 重新计算目标是否被任何活动的烟幕遮挡，并更新 IsTargetObscured 状态。
        /// 子类应在处理烟幕相关事件时调用此方法。
        /// </summary>
        protected void RecalculateObscurationStatus()
        {
            bool currentlyObscured = CheckIfTargetIsObscured(out BaseEquipment? currentTarget);

            if (IsTargetObscured != currentlyObscured)
            {
                IsTargetObscured = currentlyObscured;
            }

            // 仅当目标被看到 (未遮挡) 且目标有效时，才更新最后已知状态
            if (!currentlyObscured && currentTarget != null)
            {
                _lastKnownTargetPosition = currentTarget.Position;
                _lastKnownTargetOrientation = currentTarget.Orientation;
            }
        }

        /// <summary>
        /// 检查当前目标是否被活动烟幕遮挡。
        /// </summary>
        /// <param name="targetFound">如果成功找到目标实体，则输出该实体。</param>
        /// <returns>如果目标被遮挡，则返回 true；否则返回 false。</returns>
        private bool CheckIfTargetIsObscured(out BaseEquipment? targetFound)
        {
            targetFound = null;

            // 1. 检查指示器状态和目标ID
            if (!IsActive || string.IsNullOrEmpty(TargetId))
            {
                return false; // 未激活或无目标，视为未遮挡
            }

            // 2. 尝试获取目标实体
            targetFound = SimulationManager.GetEntityById(TargetId) as BaseEquipment;
            if (targetFound == null)
            {
                return false; // 找不到目标实体，视为未遮挡
            }

            // 3. 获取活动的烟幕
            var activeSmokeGrenades = SimulationManager.GetEntitiesByType<SmokeGrenade>()
                                                        .Where(sg => sg != null && sg.IsActive)
                                                        .ToList(); // 获取列表以便检查是否为空

            if (!activeSmokeGrenades.Any())
            {
                return false; // 没有活动的烟幕，视为未遮挡
            }

            // 4. 准备计算所需数据
            Vector3D observerPos = Position;
            Vector3D targetCenter = targetFound.Position;
            Orientation targetOrient = targetFound.Orientation;
            Vector3D targetDims = new(targetFound.Properties.Width, targetFound.Properties.Height, targetFound.Properties.Length);

            // 5. 遍历烟幕检查遮挡
            foreach (var smokeGrenade in activeSmokeGrenades)
            {
                try
                {
                    Vector3D smokeCenter = smokeGrenade.Position;
                    Orientation smokeOrient = smokeGrenade.Orientation;
                    Vector3D smokeDims;
                    if (smokeGrenade.config.SmokeType == SmokeScreenType.Cloud)
                    {
                        smokeDims = new(smokeGrenade.config.Thickness, smokeGrenade.config.CloudDiameter, smokeGrenade.config.CloudDiameter);
                    }
                    else // Wall
                    {
                        smokeDims = new(smokeGrenade.config.Thickness, smokeGrenade.config.WallHeight, smokeGrenade.config.WallWidth);
                    }

                    double ratio = ObscurationUtils.CalculateProjectedOverlapRatio(
                        observerPos,
                        smokeCenter, smokeDims, smokeOrient,
                        targetCenter, targetDims, targetOrient
                    );

                    // 只要有一个烟幕满足遮挡条件，即可判定为遮挡
                    if (ratio >= TargetObscurationThreshold)
                    {
                        return true; // 被遮挡
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"检查烟幕遮挡状态时发生错误: {ex.Message}");
                    // 在发生错误时，可以选择继续检查其他烟幕，或者直接返回一个默认值（例如 false）
                }
            }

            // 6. 如果遍历完所有烟幕都没有达到遮挡阈值
            return false; // 未被遮挡
        }

        // --- 新增干扰事件处理逻辑 ---

        /// <summary>
        /// 统一处理干扰事件
        /// </summary>
        /// <param name="evt">干扰事件</param>
        protected virtual void HandleJammingEvent(JammingEvent evt)
        {
            if (evt == null) return;

            // 在应用干扰前检查是否应该处理此干扰
            if (!ShouldHandleJamming(evt.Parameters))
            {
                 // Debug.WriteLine($"[BaseIndicator] {Id} 忽略干扰事件，类型: {evt.Parameters.Type}");
                return; 
            }

            // 如果应该处理，则应用干扰
            ApplyJamming(evt.Parameters);
        }

        /// <summary>
        /// 判断是否应该处理传入的干扰参数（可被子类重写以添加特定检查）
        /// </summary>
        /// <param name="parameters">干扰参数</param>
        /// <returns>如果应该处理则返回 true，否则返回 false</returns>
        protected virtual bool ShouldHandleJamming(JammingParameters parameters)
        {
            // 基类默认处理所有受支持类型的干扰 (包括烟幕)
            // 子类可以重写此方法添加额外检查，如波段匹配
            // 注意：烟幕干扰虽然通过这里，但主要效果通过 IsTargetObscured 和 RecalculateObscurationStatus 体现
            bool supported = SupportedJammingTypes.Contains(parameters.Type);
            // if(!supported) Debug.WriteLine($"[BaseIndicator] {Id} 不支持干扰类型: {parameters.Type}");
            return supported;
        }

         // --- 结束新增干扰事件处理逻辑 ---
    }
}