#if NEVER // 使用编译指令确保此文件永远不会被编译

// 虚幻引擎集成示例代码
// 展示如何将虚幻引擎与ThreatSource仿真系统集成
// 需要实现的核心功能: 实体同步、事件处理、状态管理

using ThreatSource.Simulation;
using ThreatSource.Data;
using ThreatSource.Missile;

/// <summary>
/// 虚幻引擎适配器类，演示如何将ThreatSource系统集成到虚幻引擎中
/// </summary>
/// <remarks>
/// 该类提供了以下功能：
/// - 虚幻引擎与仿真系统的双向通信
/// - Actor与仿真实体的映射和同步
/// - 事件的发布和订阅
/// - 数据的适配和转换
/// 本示例代码仅作为参考，展示了基本的集成方法
/// </remarks>
public class UnrealThreatSourceAdapter
{
    /// <summary>
    /// 仿真管理器实例
    /// </summary>
    private ISimulationManager _simulationManager;

    /// <summary>
    /// 数据管理器实例
    /// </summary>
    private ThreatSourceDataManager _dataManager;

    /// <summary>
    /// 实体映射字典：仿真实体ID -> 虚幻引擎Actor引用
    /// </summary>
    private Dictionary<string, object> _entityActors = new Dictionary<string, object>();

    /// <summary>
    /// 虚幻引擎接口（需要在实际项目中实现）
    /// </summary>
    public interface IUnrealEngineInterface
    {
        /// <summary>
        /// 在虚幻引擎中生成Actor
        /// </summary>
        /// <param name="actorClass">Actor类名</param>
        /// <param name="location">位置</param>
        /// <param name="rotation">旋转</param>
        /// <returns>生成的Actor引用</returns>
        object SpawnActor(string actorClass, Vector3 location, Vector3 rotation);

        /// <summary>
        /// 销毁Actor
        /// </summary>
        /// <param name="actor">要销毁的Actor</param>
        void DestroyActor(object actor);

        /// <summary>
        /// 设置Actor位置
        /// </summary>
        /// <param name="actor">Actor引用</param>
        /// <param name="location">新位置</param>
        void SetActorLocation(object actor, Vector3 location);

        /// <summary>
        /// 设置Actor旋转
        /// </summary>
        /// <param name="actor">Actor引用</param>
        /// <param name="rotation">新旋转</param>
        void SetActorRotation(object actor, Vector3 rotation);

        /// <summary>
        /// 播放特效
        /// </summary>
        /// <param name="effectName">特效名称</param>
        /// <param name="location">播放位置</param>
        void PlayEffect(string effectName, Vector3 location);
    }

    private readonly IUnrealEngineInterface _unrealEngine;

    /// <summary>
    /// 初始化虚幻引擎适配器的新实例
    /// </summary>
    /// <param name="unrealEngine">虚幻引擎接口实现</param>
    public UnrealThreatSourceAdapter(IUnrealEngineInterface unrealEngine)
    {
        _unrealEngine = unrealEngine ?? throw new ArgumentNullException(nameof(unrealEngine));
        InitializeSimulation();
    }

    /// <summary>
    /// 初始化仿真系统
    /// </summary>
    private void InitializeSimulation()
    {
        try
        {
            // 创建仿真管理器和数据管理器
            _simulationManager = new SimulationManager();
            _dataManager = new ThreatSourceDataManager();

            // 启动仿真
            _simulationManager.StartSimulation(0.02); // 20ms时间步长

            // 订阅仿真事件
            _simulationManager.Subscribe<MissileFireEvent>(OnMissileFireEvent);
            _simulationManager.Subscribe<MissileExplodeEvent>(OnMissileExplodeEvent);
            _simulationManager.Subscribe<FlightPhaseChangeEvent>(OnFlightPhaseChangeEvent);

            Console.WriteLine("ThreatSource仿真系统初始化成功");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"仿真系统初始化失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 更新仿真（应在虚幻引擎的Tick中调用）
    /// </summary>
    public void UpdateSimulation()
    {
        if (_simulationManager != null)
        {
            // 更新仿真
            _simulationManager.UpdateSimulation();

            // 同步实体状态
            SyncEntityStates();
        }
    }

    /// <summary>
    /// 同步仿真实体状态到虚幻引擎Actor
    /// </summary>
    private void SyncEntityStates()
    {
        foreach (var kvp in _entityActors)
        {
            string entityId = kvp.Key;
            object actor = kvp.Value;

            // 获取仿真实体
            var entity = _simulationManager.GetEntity(entityId);
            if (entity != null && entity.KState != null)
            {
                // 同步位置（转换坐标系：ThreatSource使用右手坐标系，虚幻引擎使用左手坐标系）
                var location = new Vector3(
                    entity.KState.Position.X,
                    -entity.KState.Position.Y, // Y轴翻转
                    entity.KState.Position.Z
                );
                _unrealEngine.SetActorLocation(actor, location);

                // 同步旋转
                var orientation = entity.KState.Orientation;
                var rotation = new Vector3(
                    orientation.Pitch * 180.0f / Math.PI, // 转换为度
                    -orientation.Yaw * 180.0f / Math.PI,   // Y轴翻转
                    orientation.Roll * 180.0f / Math.PI
                );
                _unrealEngine.SetActorRotation(actor, rotation);
            }
        }
    }

    /// <summary>
    /// 创建导弹实体
    /// </summary>
    /// <param name="missileType">导弹类型</param>
    /// <param name="location">初始位置</param>
    /// <param name="targetId">目标ID</param>
    /// <returns>导弹ID</returns>
    public string CreateMissile(string missileType, Vector3 location, string targetId)
    {
        try
        {
            // 从配置创建导弹
            var missileData = _dataManager.GetMissile(missileType);
            string missileId = $"missile_{Guid.NewGuid():N}";
            
            var missile = new InfraredImagingTerminalGuidanceMissile(missileId, missileData)
            {
                KState = new KinematicState
                {
                    Position = new ThreatSource.Simulation.Vector3(location.X, -location.Y, location.Z),
                    Velocity = new ThreatSource.Simulation.Vector3(0, 0, 0),
                    Orientation = new Orientation(0, 0, 0)
                }
            };

            // 注册到仿真系统
            _simulationManager.RegisterEntity(missile);

            // 在虚幻引擎中创建Actor
            var missileActor = _unrealEngine.SpawnActor("BP_Missile", location, new Vector3(0, 0, 0));
            if (missileActor != null)
            {
                // 建立映射关系
                _entityActors[missileId] = missileActor;

                Console.WriteLine($"创建导弹: {missileId}, 目标: {targetId}");
                return missileId;
            }
            else
            {
                Console.WriteLine($"无法在虚幻引擎中创建导弹Actor");
                return null;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"创建导弹失败: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// 创建目标实体
    /// </summary>
    /// <param name="targetId">目标ID</param>
    /// <param name="location">位置</param>
    /// <param name="velocity">速度</param>
    /// <returns>是否创建成功</returns>
    public bool CreateTarget(string targetId, Vector3 location, Vector3 velocity)
    {
        try
        {
            // 创建目标实体
            var target = new BaseEquipment(targetId)
            {
                KState = new KinematicState
                {
                    Position = new ThreatSource.Simulation.Vector3(location.X, -location.Y, location.Z),
                    Velocity = new ThreatSource.Simulation.Vector3(velocity.X, -velocity.Y, velocity.Z),
                    Orientation = new Orientation(0, 0, 0)
                }
            };

            // 注册到仿真系统
            _simulationManager.RegisterEntity(target);

            // 在虚幻引擎中创建Actor
            var targetActor = _unrealEngine.SpawnActor("BP_Target", location, new Vector3(0, 0, 0));
            if (targetActor != null)
            {
                // 建立映射关系
                _entityActors[targetId] = targetActor;

                Console.WriteLine($"创建目标: {targetId}");
                return true;
            }
            else
            {
                Console.WriteLine($"无法在虚幻引擎中创建目标Actor");
                return false;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"创建目标失败: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 处理导弹发射事件
    /// </summary>
    private void OnMissileFireEvent(MissileFireEvent evt)
    {
        Console.WriteLine($"导弹发射事件: {evt.SenderId} -> {evt.TargetId}");
        
        // 播放发射特效
        if (_entityActors.TryGetValue(evt.SenderId, out object missileActor))
        {
            // 获取导弹位置并播放发射特效
            var entity = _simulationManager.GetEntity(evt.SenderId);
            if (entity != null && entity.KState != null)
            {
                var location = new Vector3(
                    entity.KState.Position.X,
                    -entity.KState.Position.Y,
                    entity.KState.Position.Z
                );
                _unrealEngine.PlayEffect("FX_MissileLaunch", location);
            }
        }
    }

    /// <summary>
    /// 处理导弹爆炸事件
    /// </summary>
    private void OnMissileExplodeEvent(MissileExplodeEvent evt)
    {
        Console.WriteLine($"导弹爆炸事件: {evt.SenderId} 在位置 {evt.Position}");

        if (_entityActors.TryGetValue(evt.SenderId, out object missileActor))
        {
            // 播放爆炸特效
            var location = new Vector3(
                evt.Position.X,
                -evt.Position.Y,
                evt.Position.Z
            );
            _unrealEngine.PlayEffect("FX_Explosion", location);

            // 销毁导弹Actor
            _unrealEngine.DestroyActor(missileActor);
            _entityActors.Remove(evt.SenderId);
        }
    }

    /// <summary>
    /// 处理飞行阶段变化事件
    /// </summary>
    private void OnFlightPhaseChangeEvent(FlightPhaseChangeEvent evt)
    {
        Console.WriteLine($"导弹 {evt.SenderId} 进入 {evt.NewPhase} 阶段");

        // 可以根据飞行阶段改变导弹的视觉表现
        if (_entityActors.TryGetValue(evt.SenderId, out object missileActor))
        {
            switch (evt.NewPhase)
            {
                case FlightPhase.Boost:
                    // 助推阶段：播放推进器特效
                    _unrealEngine.PlayEffect("FX_BoostTrail", GetActorLocation(missileActor));
                    break;
                case FlightPhase.Midcourse:
                    // 中段飞行：调整拖尾特效
                    _unrealEngine.PlayEffect("FX_MidcourseTrail", GetActorLocation(missileActor));
                    break;
                case FlightPhase.Terminal:
                    // 末段制导：改变特效颜色
                    _unrealEngine.PlayEffect("FX_TerminalTrail", GetActorLocation(missileActor));
                    break;
            }
        }
    }

    /// <summary>
    /// 获取Actor位置（示例方法，实际需要通过虚幻引擎API实现）
    /// </summary>
    private Vector3 GetActorLocation(object actor)
    {
        // 这里应该调用虚幻引擎的API获取Actor位置
        // 示例返回零向量
        return new Vector3(0, 0, 0);
    }

    /// <summary>
    /// 清理仿真系统
    /// </summary>
    public void Cleanup()
    {
        if (_simulationManager != null)
        {
            _simulationManager.StopSimulation();
            _simulationManager = null;
        }

        // 清理Actor映射
        foreach (var actor in _entityActors.Values)
        {
            _unrealEngine.DestroyActor(actor);
        }
        _entityActors.Clear();

        Console.WriteLine("ThreatSource仿真系统已清理");
    }
}

/// <summary>
/// 虚幻引擎仿真示例类
/// </summary>
/// <remarks>
/// 该类演示了：
/// - 虚幻引擎仿真系统的初始化
/// - 适配器的配置和使用
/// - 事件系统的使用
/// 用于指导实际项目中的集成实现
/// </remarks>
public class UnrealSimulationExample
{
    private UnrealThreatSourceAdapter _adapter;
    private UnrealThreatSourceAdapter.IUnrealEngineInterface _unrealEngine;

    /// <summary>
    /// 初始化示例
    /// </summary>
    /// <param name="unrealEngine">虚幻引擎接口实现</param>
    public void Initialize(UnrealThreatSourceAdapter.IUnrealEngineInterface unrealEngine)
    {
        _unrealEngine = unrealEngine;
        _adapter = new UnrealThreatSourceAdapter(_unrealEngine);

        Console.WriteLine("虚幻引擎ThreatSource集成示例初始化完成");
    }

    /// <summary>
    /// 运行示例场景
    /// </summary>
    public void RunExampleScene()
    {
        try
        {
            // 创建目标
            var targetLocation = new Vector3(5000, 0, 1000); // 5km距离，1km高度
            var targetVelocity = new Vector3(-50, 0, 0);     // 50m/s向西移动
            _adapter.CreateTarget("target_001", targetLocation, targetVelocity);

            // 创建导弹
            var missileLocation = new Vector3(0, 0, 100);    // 起始位置
            string missileId = _adapter.CreateMissile("IR_Missile_Example", missileLocation, "target_001");

            if (!string.IsNullOrEmpty(missileId))
            {
                Console.WriteLine($"示例场景创建成功 - 导弹: {missileId}, 目标: target_001");
            }
            else
            {
                Console.WriteLine("示例场景创建失败");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"运行示例场景失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 更新仿真（应在虚幻引擎的Tick中调用）
    /// </summary>
    public void Tick()
    {
        _adapter?.UpdateSimulation();
    }

    /// <summary>
    /// 清理资源
    /// </summary>
    public void Cleanup()
    {
        _adapter?.Cleanup();
        Console.WriteLine("虚幻引擎ThreatSource集成示例已清理");
    }
}

/// <summary>
/// 虚幻引擎接口的示例实现（仅用于演示）
/// </summary>
/// <remarks>
/// 实际项目中需要使用真实的虚幻引擎API实现此接口
/// </remarks>
public class MockUnrealEngineInterface : UnrealThreatSourceAdapter.IUnrealEngineInterface
{
    private Dictionary<object, Vector3> _actorLocations = new Dictionary<object, Vector3>();
    private Dictionary<object, Vector3> _actorRotations = new Dictionary<object, Vector3>();

    public object SpawnActor(string actorClass, Vector3 location, Vector3 rotation)
    {
        var actor = new object(); // 模拟Actor对象
        _actorLocations[actor] = location;
        _actorRotations[actor] = rotation;
        Console.WriteLine($"模拟生成Actor: {actorClass} 在位置 {location}");
        return actor;
    }

    public void DestroyActor(object actor)
    {
        _actorLocations.Remove(actor);
        _actorRotations.Remove(actor);
        Console.WriteLine("模拟销毁Actor");
    }

    public void SetActorLocation(object actor, Vector3 location)
    {
        if (_actorLocations.ContainsKey(actor))
        {
            _actorLocations[actor] = location;
        }
    }

    public void SetActorRotation(object actor, Vector3 rotation)
    {
        if (_actorRotations.ContainsKey(actor))
        {
            _actorRotations[actor] = rotation;
        }
    }

    public void PlayEffect(string effectName, Vector3 location)
    {
        Console.WriteLine($"模拟播放特效: {effectName} 在位置 {location}");
    }
}

#endif // 结束编译指令块