using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows;
using System.Windows.Input;
using System.Threading.Tasks;
using System.Linq;
using System.IO;
using System.Numerics;
using Microsoft.Win32;
using Autodesk.Navisworks.Api;
using NavisApplication = Autodesk.Navisworks.Api.Application;
using NavisworksTransport.Core;
using NavisworksTransport.Core.Config;
using NavisworksTransport.Commands;
using NavisworksTransport.UI.WPF.Views;
using NavisworksTransport.UI.WPF.Models;
using NavisworksTransport.Utils;
using NavisworksTransport.Utils.CoordinateSystem;
using NavisworksTransport.Utils.GeometryAnalysis;

namespace NavisworksTransport.UI.WPF.ViewModels
{
    /// <summary>
    /// 路径策略选项辅助类
    /// </summary>
    public class PathStrategyOption
    {
        /// <summary>
        /// 策略值
        /// </summary>
        public PathStrategy Value { get; set; }

        /// <summary>
        /// 显示名称
        /// </summary>
        public string DisplayName { get; set; }

        /// <summary>
        /// 详细描述
        /// </summary>
        public string Description { get; set; }
    }

    /// <summary>
    /// Rail 构型选项辅助类
    /// </summary>
    /// <typeparam name="T">枚举类型</typeparam>
    public class RailConfigOption<T>
    {
        /// <summary>
        /// 配置值
        /// </summary>
        public T Value { get; set; }

        /// <summary>
        /// 显示名称
        /// </summary>
        public string DisplayName { get; set; }

        /// <summary>
        /// 详细描述
        /// </summary>
        public string Description { get; set; }
    }

    /// <summary>
    /// 路径编辑页面专用ViewModel
    /// </summary>
    public class PathEditingViewModel : ViewModelBase, IDisposable
    {
        #region 私有字段

        private PathPlanningManager _pathPlanningManager;
        private readonly UIStateManager _uiStateManager;
        private readonly PathDataManager _pathDataManager;

        // 路径集合
        private ObservableCollection<PathRouteViewModel> _pathRoutes;
        private PathRouteViewModel _selectedPathRoute;
        private PathPointViewModel _selectedPathPoint;
        private bool _isPathEditMode;

        // 自动路径规划参数
        private string _autoPathStartPoint = "未选择";
        private string _autoPathEndPoint = "未选择";
        private Point3D _startPoint3D;
        private Point3D _endPoint3D;
        private bool _hasStartPoint = false;
        private bool _hasEndPoint = false;
        private bool _isSelectingStartPoint = false;
        private bool _isSelectingEndPoint = false;

        // 物体参数 - 改为三个独立参数（从配置初始化）
        private double _objectLength;  // 物体长度（米）
        private double _objectWidth;   // 物体宽度（米）
        private double _objectHeight;  // 物体高度（米）
        private double _safetyMargin;  // 安全间隙（米）

        // 网格大小参数（从配置初始化）
        private bool _isGridSizeManuallyEnabled = false;  // 是否启用手动网格大小设置
        private double _gridSize;  // 网格大小（米）

        // 可视化参数
        private bool _showWalkableGrid = false;
        private bool _showObstacleGrid = false;
        private bool _showUnknownGrid = false;
        private bool _showDoorGrid = false;
        private GridPointType _gridPointType = GridPointType.Rectangle;
        // 三种渲染模式独立开关
        private bool _showControlVisualization = true;  // 默认显示控制点连线
        private bool _showPathLines = true;             // 默认显示路径线（地面连线）
        private bool _showObjectSpace = false;         // 默认不显示通行空间
        // 渲染模式已改为独立开关（_showControlVisualization, _showPathLines, _showObjectSpace）
        // 下面的互斥属性已废弃并删除

        // 路径策略参数
        private PathStrategyOption _selectedPathStrategy;
        private ObservableCollection<PathStrategyOption> _pathStrategyOptions;
        private ObservableCollection<RailConfigOption<RailMountMode>> _railMountModeOptions;
        private const double DefaultAssemblyReferenceRodLengthInMeters = 20.0;
        private static readonly double DefaultAssemblyReferenceRodDiameterInMeters = CalculateDefaultAssemblyReferenceRodDiameterInMeters();
        private const double DefaultAssemblyAnchorVerticalOffsetInMeters = 0.0;
        private const double AssemblyVisualizationPointDiameterInMeters = 0.05;
        private const double RailNormalOffsetNudgeStepInMeters = 0.1;
        private const double DefaultAssemblySphereCenterX = 0.0;
        private const double DefaultAssemblySphereCenterY = 0.0;
        private const double DefaultAssemblySphereCenterZ = 0.0;
        private readonly RailAssemblyWorkflowContext _railAssemblyContext = new RailAssemblyWorkflowContext(
            DefaultAssemblyReferenceRodLengthInMeters,
            DefaultAssemblyReferenceRodDiameterInMeters,
            DefaultAssemblyAnchorVerticalOffsetInMeters,
            DefaultAssemblySphereCenterX,
            DefaultAssemblySphereCenterY,
            DefaultAssemblySphereCenterZ);
        private const string AssemblyAnchorMarkerPathId = "assembly_anchor_marker";
        private const string AssemblyCenterGuideLinePathId = "assembly_center_guide_line";
        private const string AssemblyReferenceLinePathId = "assembly_reference_line";
        private const string AssemblyEndFaceSeedPathId = "assembly_end_face_seed_points";
        private const string AssemblyEndFaceCenterPathId = "assembly_end_face_center";
        private const string AssemblyEndFaceNormalPathId = "assembly_end_face_normal";
        private const string AssemblyInstallationPickPointPathId = "assembly_install_pick_point";
        private const string AssemblyInstallationAnchorPointPathId = "assembly_install_anchor_point";
        private const string AssemblyInstallationCenterLinePathId = "assembly_install_center_line";
        private const string AssemblyInstallationOffsetLinePathId = "assembly_install_offset_line";
        private const string AssemblyInstallationPlanePathId = "assembly_install_plane";
        private const double AssemblyInstallationPlanePaddingInMeters = 0.5;
        private const double AssemblyInstallationLineLengthScale = 1.2;

        private string _assemblyTerminalObjectName
        {
            get => _railAssemblyContext.TerminalObjectName;
            set => _railAssemblyContext.TerminalObjectName = value;
        }

        private string _assemblyTerminalObjectInfo
        {
            get => _railAssemblyContext.TerminalObjectInfo;
            set => _railAssemblyContext.TerminalObjectInfo = value;
        }

        private double _assemblyReferenceRodLengthInMeters
        {
            get => _railAssemblyContext.ReferenceRodLengthInMeters;
            set => _railAssemblyContext.ReferenceRodLengthInMeters = value;
        }

        private double _assemblyReferenceRodDiameterInMeters
        {
            get => _railAssemblyContext.ReferenceRodDiameterInMeters;
            set => _railAssemblyContext.ReferenceRodDiameterInMeters = value;
        }

        private double _assemblyAnchorVerticalOffsetInMeters
        {
            get => _railAssemblyContext.AnchorVerticalOffsetInMeters;
            set => _railAssemblyContext.AnchorVerticalOffsetInMeters = value;
        }

        private double _assemblySphereCenterX
        {
            get => _railAssemblyContext.SphereCenterX;
            set => _railAssemblyContext.SphereCenterX = value;
        }

        private double _assemblySphereCenterY
        {
            get => _railAssemblyContext.SphereCenterY;
            set => _railAssemblyContext.SphereCenterY = value;
        }

        private double _assemblySphereCenterZ
        {
            get => _railAssemblyContext.SphereCenterZ;
            set => _railAssemblyContext.SphereCenterZ = value;
        }

        private string _assemblyStartPointText
        {
            get => _railAssemblyContext.StartPointText;
            set => _railAssemblyContext.StartPointText = value;
        }

        private RailMountMode _assemblyMountMode
        {
            get => _railAssemblyContext.MountMode;
            set => _railAssemblyContext.MountMode = value;
        }

        private bool _hasAssemblyTerminalObject
        {
            get => _railAssemblyContext.HasTerminalObject;
            set => _railAssemblyContext.HasTerminalObject = value;
        }

        private bool _isSelectingAssemblyStartPoint
        {
            get => _railAssemblyContext.IsSelectingStartPoint;
            set => _railAssemblyContext.IsSelectingStartPoint = value;
        }

        private bool _isSelectingAssemblyEndFacePoints
        {
            get => _railAssemblyContext.IsSelectingEndFacePoints;
            set => _railAssemblyContext.IsSelectingEndFacePoints = value;
        }

        private bool _isSelectingAssemblyInstallationPoint
        {
            get => _railAssemblyContext.IsSelectingInstallationPoint;
            set => _railAssemblyContext.IsSelectingInstallationPoint = value;
        }

        private RailAssemblyWorkflowMode _railAssemblyWorkflowMode
        {
            get => _railAssemblyContext.WorkflowMode;
            set => _railAssemblyContext.WorkflowMode = value;
        }

        private bool _hasAssemblyEndFaceAnalysis
        {
            get => _railAssemblyContext.HasEndFaceAnalysis;
            set => _railAssemblyContext.HasEndFaceAnalysis = value;
        }

        private bool _hasAssemblyInstallationReference
        {
            get => _railAssemblyContext.HasInstallationReference;
            set => _railAssemblyContext.HasInstallationReference = value;
        }

        private ModelItem _assemblyTerminalObject
        {
            get => _railAssemblyContext.TerminalObject;
            set => _railAssemblyContext.TerminalObject = value;
        }

        private Point3D _assemblyStartPoint
        {
            get => _railAssemblyContext.StartPoint;
            set => _railAssemblyContext.StartPoint = value;
        }

        private Point3D _assemblyEndFaceCenterPoint
        {
            get => _railAssemblyContext.EndFaceCenterPoint;
            set => _railAssemblyContext.EndFaceCenterPoint = value;
        }

        private Vector3 _assemblyEndFaceNormal
        {
            get => _railAssemblyContext.EndFaceNormal;
            set => _railAssemblyContext.EndFaceNormal = value;
        }

        private Point3D _assemblyInstallationPickPoint
        {
            get => _railAssemblyContext.InstallationPickPoint;
            set => _railAssemblyContext.InstallationPickPoint = value;
        }

        private Point3D _assemblyInstallationBaseAnchorPoint
        {
            get => _railAssemblyContext.InstallationBaseAnchorPoint;
            set => _railAssemblyContext.InstallationBaseAnchorPoint = value;
        }

        private Point3D _assemblyInstallationAnchorPoint
        {
            get => _railAssemblyContext.InstallationAnchorPoint;
            set => _railAssemblyContext.InstallationAnchorPoint = value;
        }

        private Vector3 _assemblyInstallationPlaneNormal
        {
            get => _railAssemblyContext.InstallationPlaneNormal;
            set => _railAssemblyContext.InstallationPlaneNormal = value;
        }

        private Vector3 _assemblyInstallationPlaneSpanDirection
        {
            get => _railAssemblyContext.InstallationPlaneSpanDirection;
            set => _railAssemblyContext.InstallationPlaneSpanDirection = value;
        }

        private double _assemblyInstallationOffsetDistanceInMeters
        {
            get => _railAssemblyContext.InstallationOffsetDistanceInMeters;
            set => _railAssemblyContext.InstallationOffsetDistanceInMeters = value;
        }

        private string _assemblyInstallationReferenceRouteId
        {
            get => _railAssemblyContext.InstallationReferenceRouteId;
            set => _railAssemblyContext.InstallationReferenceRouteId = value;
        }

        private List<Point3D> _assemblyInstallationSeedPoints => _railAssemblyContext.InstallationSeedPoints;

        private List<Point3D> _assemblyEndFaceSeedPoints => _railAssemblyContext.EndFaceSeedPoints;

        // 自动路径起点和终点的路径对象引用（用于正确的ID管理）
        private PathRoute _autoPathStartPointRoute = null;
        private PathRoute _autoPathEndPointRoute = null;


        // 资源清理管理
        private bool _disposed = false;

        // 多层吊装模式
        private bool _isMultiLevelHoistingMode = false;
        private ObservableCollection<HoistingLevelItem> _multiLevelItems = new ObservableCollection<HoistingLevelItem>();
        private Point3D _multiLevelStartPoint;
        private Point3D _multiLevelEndPoint;
        private bool _hasMultiLevelStartPoint = false;
        private bool _hasMultiLevelEndPoint = false;
        private string _multiLevelStartPointText = "未选择";
        private string _multiLevelEndPointText = "未选择";
        private string _multiLevelStatsText = "层级数: 0 | 预估路径点数: 0";
        private bool _isSelectingMultiLevelStartPoint = false;
        private bool _isSelectingMultiLevelEndPoint = false;
        private HoistingLevelItem _currentSelectingLevelTarget;

        #endregion

        #region 公共属性

        public ObservableCollection<PathRouteViewModel> PathRoutes
        {
            get => _pathRoutes;
            set => SetProperty(ref _pathRoutes, value);
        }

        public PathRouteViewModel SelectedPathRoute
        {
            get => _selectedPathRoute;
            set
            {
                if (SetProperty(ref _selectedPathRoute, value))
                {
                    // 路径变更时清除选中的路径点
                    SelectedPathPoint = null;
                    ResetRailAssemblyWorkflowState(announce: false);

                    // 🔧 修复：同步PathPlanningManager的CurrentRoute
                    if (_pathPlanningManager != null && value != null)
                    {
                        // 查找对应的Core路径对象
                        var coreRoute = _pathPlanningManager.Routes?.FirstOrDefault(r => r.Id == value.Id)
                            ?? _pathPlanningManager.Routes?.FirstOrDefault(r => r.Name == value.Name);
                        if (coreRoute != null)
                        {
                            if (coreRoute.PathType == PathType.Rail)
                            {
                                AssemblyMountMode = coreRoute.RailMountMode;
                                _assemblyAnchorVerticalOffsetInMeters = UnitsConverter.ConvertToMeters(coreRoute.RailNormalOffset);
                                OnPropertyChanged(nameof(AssemblyAnchorVerticalOffsetInMeters));
                            }

                            // 🔥 先设置可视化模式（在 SetCurrentRoute 之前，确保事件触发时状态已就绪）
                            UpdatePassageSpaceVisualizationForPathType(coreRoute.PathType);
                            
                            _pathPlanningManager.SetCurrentRoute(coreRoute);
                            LogManager.Info($"UI路径切换：已同步PathPlanningManager的CurrentRoute到 {value.Name}");

                            // 自动调整视角到路径中心（只有路径有点时才调整）
                            if (coreRoute.Points.Count > 0)
                            {
                                try
                                {
                                    ViewpointHelper.AdjustViewpointForPath(coreRoute);
                                    LogManager.Info($"UI路径切换：已自动调整视角: {value.Name}, 类型={coreRoute.PathType}");
                                }
                                catch (Exception ex)
                                {
                                    LogManager.Error($"UI路径切换：调整视角失败: {ex.Message}");
                                }
                            }
                            else
                            {
                                LogManager.Info($"UI路径切换：路径还没有点，跳过视角调整: {value.Name}");
                            }
                        }
                        else
                        {
                            LogManager.Warning($"UI路径切换：未找到对应的Core路径 {value.Name}");
                        }
                    }
                    else if (_pathPlanningManager != null && value == null)
                    {
                        // 如果选择了null，也要同步清除CurrentRoute
                        _pathPlanningManager.SetCurrentRoute(null);
                        LogManager.Info("UI路径切换：已清除PathPlanningManager的CurrentRoute");
                    }

                    // 更新命令状态
                    OnPropertyChanged(nameof(CanExecuteStartEdit));
                    OnPropertyChanged(nameof(CanExecuteEndEdit));
                    OnPropertyChanged(nameof(CanExecuteClearPath));
                    OnPropertyChanged(nameof(CanExecuteExportPath));
                    OnPropertyChanged(nameof(CanExecuteSaveAsPath));
                    OnPropertyChanged(nameof(CanExecuteModifyPoint));

                    // 🔥 路径类型改变时，检查是否可以使用路径线
                    OnPropertyChanged(nameof(CanUsePathLines));
                    OnPropertyChanged(nameof(IsRailRouteSelected));
                    OnPropertyChanged(nameof(SelectedRailMountMode));
                    OnPropertyChanged(nameof(SelectedRailNormalOffsetInMeters));
                    OnPropertyChanged(nameof(CanRepositionRailStartPoint));
                    NotifyRailAssemblyCommandStateChanged();
                    if (!CanUsePathLines && ShowPathLines)
                    {
                        // 吊装和空轨路径不能使用路径线，自动关闭
                        ShowPathLines = false;
                        LogManager.Info("[路径可视化] 切换到吊装/空轨路径，自动关闭路径线");
                    }

                    // 实现路径选择时的可视化切换
                    UpdatePathVisualization();
                }
            }
        }

        public PathPointViewModel SelectedPathPoint
        {
            get => _selectedPathPoint;
            set
            {
                if (SetProperty(ref _selectedPathPoint, value))
                {
                    // 更新修改路径点按钮的启用状态
                    OnPropertyChanged(nameof(CanExecuteModifyPoint));

                    // 路径点选中可视化：将选中的路径点显示为预览样式
                    try
                    {
                        if (value != null)
                        {
                            // 从PathPointViewModel创建PathPoint对象
                            var pathPoint = new PathPoint(
                                new Point3D(value.X, value.Y, value.Z),
                                value.Name,
                                value.Type
                            )
                            {
                                Id = value.Id
                            };

                            // 将选中的路径点设为预览样式
                            PathPointRenderPlugin.Instance.RenderPreviewPoint(pathPoint);
                            LogManager.Info($"路径点已设为预览样式: {value.Name}");
                        }
                        else
                        {
                            // 清除预览样式
                            PathPointRenderPlugin.Instance.ClearPreviewPoint();
                            LogManager.Info("已清除路径点预览样式");
                        }
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"路径点选中可视化失败: {ex.Message}");
                    }
                }
            }
        }

        public bool IsRailRouteSelected => SelectedPathRoute?.PathType == PathType.Rail;

        public ObservableCollection<RailConfigOption<RailMountMode>> RailMountModeOptions
        {
            get => _railMountModeOptions;
        }

        public RailMountMode SelectedRailMountMode
        {
            get => GetSelectedCoreRoute()?.RailMountMode ?? RailMountMode.UnderRail;
            set
            {
                var coreRoute = GetSelectedCoreRoute();
                if (coreRoute == null || coreRoute.PathType != PathType.Rail || coreRoute.RailMountMode == value)
                {
                    return;
                }

                coreRoute.RailMountMode = value;
                AssemblyMountMode = value;
                ApplyRailRouteConfigurationChange(coreRoute, $"安装方式已更新为 {value}");
                OnPropertyChanged(nameof(SelectedRailMountMode));
            }
        }

        public double SelectedRailNormalOffsetInMeters
        {
            get
            {
                var coreRoute = GetSelectedCoreRoute();
                if (coreRoute == null || coreRoute.PathType != PathType.Rail)
                {
                    return 0.0;
                }

                return UnitsConverter.ConvertToMeters(coreRoute.RailNormalOffset);
            }
            set
            {
                var coreRoute = GetSelectedCoreRoute();
                if (coreRoute == null || coreRoute.PathType != PathType.Rail)
                {
                    return;
                }

                double offsetInModelUnits = UnitsConverter.ConvertFromMeters(value);
                if (Math.Abs(coreRoute.RailNormalOffset - offsetInModelUnits) < 1e-6)
                {
                    return;
                }

                _assemblyAnchorVerticalOffsetInMeters = value;
                OnPropertyChanged(nameof(AssemblyAnchorVerticalOffsetInMeters));
                coreRoute.RailNormalOffset = offsetInModelUnits;
                if (IsAssemblyInstallationReferenceActiveForRoute(coreRoute))
                {
                    UpdateAssemblyInstallationAnchorFromVerticalOffset();
                    PersistAssemblyInstallationReferenceToRailRoute(coreRoute, $"安装法向偏移已更新为 {value:F3} 米");
                }
                else
                {
                    ApplyRailRouteConfigurationChange(coreRoute, $"安装法向偏移已更新为 {value:F3} 米");
                }
                OnPropertyChanged(nameof(SelectedRailNormalOffsetInMeters));
            }
        }

        public string AssemblyTerminalObjectName
        {
            get => _assemblyTerminalObjectName;
            set
            {
                if (string.Equals(_assemblyTerminalObjectName, value, StringComparison.Ordinal))
                {
                    return;
                }

                _assemblyTerminalObjectName = value;
                OnPropertyChanged(nameof(AssemblyTerminalObjectName));
            }
        }

        public string AssemblyTerminalObjectInfo
        {
            get => _assemblyTerminalObjectInfo;
            set
            {
                if (string.Equals(_assemblyTerminalObjectInfo, value, StringComparison.Ordinal))
                {
                    return;
                }

                _assemblyTerminalObjectInfo = value;
                OnPropertyChanged(nameof(AssemblyTerminalObjectInfo));
            }
        }

        public double AssemblyReferenceRodLengthInMeters
        {
            get => _assemblyReferenceRodLengthInMeters;
            set
            {
                if (Math.Abs(_assemblyReferenceRodLengthInMeters - value) < 1e-9)
                {
                    return;
                }

                _assemblyReferenceRodLengthInMeters = value;
                OnPropertyChanged(nameof(AssemblyReferenceRodLengthInMeters));
            }
        }

        public double AssemblyReferenceRodDiameterInMeters
        {
            get => _assemblyReferenceRodDiameterInMeters;
            set
            {
                if (Math.Abs(_assemblyReferenceRodDiameterInMeters - value) < 1e-9)
                {
                    return;
                }

                _assemblyReferenceRodDiameterInMeters = value;
                OnPropertyChanged(nameof(AssemblyReferenceRodDiameterInMeters));
            }
        }

        public double AssemblyAnchorVerticalOffsetInMeters
        {
            get => _assemblyAnchorVerticalOffsetInMeters;
            set
            {
                if (Math.Abs(_assemblyAnchorVerticalOffsetInMeters - value) < 1e-9)
                {
                    return;
                }

                _assemblyAnchorVerticalOffsetInMeters = value;
                OnPropertyChanged(nameof(AssemblyAnchorVerticalOffsetInMeters));

                if (HasAssemblyTerminalObject)
                {
                    var coreRoute = GetSelectedCoreRoute();
                    if (_hasAssemblyInstallationReference)
                    {
                        UpdateAssemblyInstallationAnchorFromVerticalOffset();
                        if (IsAssemblyInstallationReferenceActiveForRoute(coreRoute))
                        {
                            PersistAssemblyInstallationReferenceToRailRoute(coreRoute, $"安装法向偏移已更新为 {value:F3} 米");
                        }
                    }
                    RefreshAssemblyTerminalObjectInfo();
                    if (coreRoute != null &&
                        coreRoute.PathType == PathType.Rail &&
                        AssemblyReferencePathManager.Instance.HasReferenceLine)
                    {
                        RefreshSelectedRailReferenceLineVisuals();
                    }
                    else
                    {
                        RefreshAssemblyReferenceRodIfNeeded();
                    }
                }
            }
        }

        public double AssemblySphereCenterX
        {
            get => _assemblySphereCenterX;
            set
            {
                if (Math.Abs(_assemblySphereCenterX - value) < 1e-9)
                {
                    return;
                }

                _assemblySphereCenterX = value;
                OnPropertyChanged(nameof(AssemblySphereCenterX));

                if (HasAssemblyTerminalObject)
                {
                    RefreshAssemblyTerminalObjectInfo();
                    RefreshAssemblyReferenceRodIfNeeded();
                }
            }
        }

        public double AssemblySphereCenterY
        {
            get => _assemblySphereCenterY;
            set
            {
                if (Math.Abs(_assemblySphereCenterY - value) < 1e-9)
                {
                    return;
                }

                _assemblySphereCenterY = value;
                OnPropertyChanged(nameof(AssemblySphereCenterY));

                if (HasAssemblyTerminalObject)
                {
                    RefreshAssemblyTerminalObjectInfo();
                    RefreshAssemblyReferenceRodIfNeeded();
                }
            }
        }

        public double AssemblySphereCenterZ
        {
            get => _assemblySphereCenterZ;
            set
            {
                if (Math.Abs(_assemblySphereCenterZ - value) < 1e-9)
                {
                    return;
                }

                _assemblySphereCenterZ = value;
                OnPropertyChanged(nameof(AssemblySphereCenterZ));

                if (HasAssemblyTerminalObject)
                {
                    RefreshAssemblyTerminalObjectInfo();
                    RefreshAssemblyReferenceRodIfNeeded();
                }
            }
        }

        public bool HasAssemblyTerminalObject
        {
            get => _hasAssemblyTerminalObject;
            set
            {
                if (_hasAssemblyTerminalObject == value)
                {
                    return;
                }

                _hasAssemblyTerminalObject = value;
                OnPropertyChanged(nameof(HasAssemblyTerminalObject));
            }
        }

        public string AssemblyStartPointText
        {
            get => _assemblyStartPointText;
            set
            {
                if (string.Equals(_assemblyStartPointText, value, StringComparison.Ordinal))
                {
                    return;
                }

                _assemblyStartPointText = value;
                OnPropertyChanged(nameof(AssemblyStartPointText));
            }
        }

        public RailMountMode AssemblyMountMode
        {
            get => _assemblyMountMode;
            set
            {
                if (_assemblyMountMode == value)
                {
                    return;
                }

                _assemblyMountMode = value;
                OnPropertyChanged(nameof(AssemblyMountMode));

                if (HasAssemblyTerminalObject)
                {
                    RefreshAssemblyTerminalObjectInfo();
                    RefreshAssemblyReferenceRodIfNeeded();
                }
            }
        }

        public bool IsSelectingAssemblyStartPoint
        {
            get => _isSelectingAssemblyStartPoint;
            set
            {
                if (_isSelectingAssemblyStartPoint == value)
                {
                    return;
                }

                _isSelectingAssemblyStartPoint = value;
                OnPropertyChanged(nameof(IsSelectingAssemblyStartPoint));
            }
        }
        /// <summary>
        /// 更新路径可视化显示：清理其他路径，只显示当前选中的路径
        /// </summary>
        private async void UpdatePathVisualization()
        {
            await SafeExecuteAsync(() =>
            {
                try
                {
                    if (PathPointRenderPlugin.Instance == null)
                    {
                        LogManager.Warning("PathPointRenderPlugin实例为空，无法更新路径可视化");
                        return;
                    }

                    // 0. 先同步物体参数到渲染插件
                    SyncObjectParametersToRenderPlugin();

                    // 检查是否在编辑状态
                    bool isInEditMode = _pathPlanningManager?.IsInEditableState ?? false;
                    
                    // 1. 清理现有的路径可视化，但保留网格可视化和正在编辑的路径
                    if (isInEditMode)
                    {
                        // 在编辑状态，不清空路径，避免清空正在编辑的路径
                        LogManager.Debug("[路径可视化] 在编辑状态，跳过清空路径可视化");
                    }
                    else
                    {
                        // 不在编辑状态，清空所有路径可视化，但保留网格可视化
                        PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                    }

                    // 2. 如果有选中的路径，则显示该路径
                    if (_selectedPathRoute != null && _selectedPathRoute.Points.Count > 0)
                    {
                        // 查找对应的Core路径对象
                        var coreRoute = _pathPlanningManager?.Routes?.FirstOrDefault(r => r.Id == _selectedPathRoute.Id)
                            ?? _pathPlanningManager?.Routes?.FirstOrDefault(r => r.Name == _selectedPathRoute.Name);
                        if (coreRoute != null)
                        {
                            // 使用PathPlanningManager的绘制方法来保持一致性
                            _pathPlanningManager.DrawRouteVisualization(coreRoute, isAutoPath: false);
                            LogManager.Info($"[路径可视化] 已显示选中路径: {_selectedPathRoute.Name}，包含 {_selectedPathRoute.Points.Count} 个点");
                        }
                        else
                        {
                            LogManager.Warning($"[路径可视化] 未找到对应的Core路径: {_selectedPathRoute.Name}");
                        }
                    }

                    RefreshSelectedRailInstallationReferenceVisuals();

                    // 3. 恢复网格可视化（如果网格可视化已启用且当前路径有关联的GridMap）
                    if (_pathPlanningManager?.IsAnyGridVisualizationEnabled == true)
                    {
                        // 检查当前路径是否有关联的GridMap
                        var currentRoute = _pathPlanningManager.CurrentRoute;
                        if (currentRoute?.AssociatedGridMap != null)
                        {
                            // 通过PathPlanningManager的RefreshGridVisualization方法恢复网格
                            // 这会使用当前路径的AssociatedGridMap来重新渲染网格
                            var refreshMethod = typeof(PathPlanningManager).GetMethod("RefreshGridVisualization",
                                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                            if (refreshMethod != null)
                            {
                                refreshMethod.Invoke(_pathPlanningManager, null);
                            }
                            else
                            {
                                LogManager.Warning("[路径可视化] 无法找到RefreshGridVisualization方法");
                            }
                        }
                        else
                        {
                            LogManager.Debug("[路径可视化] 当前路径没有关联的GridMap，跳过网格恢复");
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Error($"[路径可视化] 更新路径可视化失败: {ex.Message}", ex);
                }
            }, "更新路径可视化");
        }

        public bool IsPathEditMode
        {
            get => _isPathEditMode;
            set => SetProperty(ref _isPathEditMode, value);
        }

        #region 自动路径规划属性

        public string AutoPathStartPoint
        {
            get => _autoPathStartPoint;
            set => SetProperty(ref _autoPathStartPoint, value);
        }

        public string AutoPathEndPoint
        {
            get => _autoPathEndPoint;
            set => SetProperty(ref _autoPathEndPoint, value);
        }

        #region 多层吊装属性

        public bool IsMultiLevelHoistingMode
        {
            get => _isMultiLevelHoistingMode;
            set => SetProperty(ref _isMultiLevelHoistingMode, value);
        }

        public ObservableCollection<HoistingLevelItem> MultiLevelItems
        {
            get => _multiLevelItems;
            set => SetProperty(ref _multiLevelItems, value);
        }

        public string MultiLevelStartPointText
        {
            get => _multiLevelStartPointText;
            set => SetProperty(ref _multiLevelStartPointText, value);
        }

        public string MultiLevelEndPointText
        {
            get => _multiLevelEndPointText;
            set => SetProperty(ref _multiLevelEndPointText, value);
        }

        public string MultiLevelStatsText
        {
            get => _multiLevelStatsText;
            set => SetProperty(ref _multiLevelStatsText, value);
        }

        public bool CanCreateMultiLevelPath => _hasMultiLevelStartPoint && _hasMultiLevelEndPoint && _multiLevelItems.Count > 0;

        #endregion

        public double ObjectLength
        {
            get => _objectLength;
            set
            {
                if (SetProperty(ref _objectLength, value))
                {
                    SyncObjectParametersToRenderPlugin();
                    OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                }
            }
        }

        public double ObjectWidth
        {
            get => _objectWidth;
            set
            {
                if (SetProperty(ref _objectWidth, value))
                {
                    SyncObjectParametersToRenderPlugin();
                    OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                }
            }
        }

        public double ObjectHeight
        {
            get => _objectHeight;
            set
            {
                if (SetProperty(ref _objectHeight, value))
                {
                    SyncObjectParametersToRenderPlugin();
                    OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                }
            }
        }

        public double SafetyMargin
        {
            get => _safetyMargin;
            set
            {
                // 限制精度到2位小数
                var roundedValue = Math.Round(value, 2);
                if (SetProperty(ref _safetyMargin, roundedValue))
                {
                    SyncObjectParametersToRenderPlugin();
                    OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                }
            }
        }

        public bool IsGridSizeManuallyEnabled
        {
            get => _isGridSizeManuallyEnabled;
            set
            {
                if (SetProperty(ref _isGridSizeManuallyEnabled, value))
                {
                    OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                }
            }
        }

        public double GridSize
        {
            get => _gridSize;
            set
            {
                // 限制精度到1位小数
                var roundedValue = Math.Round(value, 1);
                if (SetProperty(ref _gridSize, roundedValue))
                {
                    OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                }
            }
        }

        #region 可视化参数属性

        /// <summary>
        /// 是否显示可通行网格点
        /// </summary>
        public bool ShowWalkableGrid
        {
            get => _showWalkableGrid;
            set
            {
                if (SetProperty(ref _showWalkableGrid, value))
                {
                    OnGridVisualizationChanged();
                }
            }
        }

        /// <summary>
        /// 是否显示障碍物网格点
        /// </summary>
        public bool ShowObstacleGrid
        {
            get => _showObstacleGrid;
            set
            {
                if (SetProperty(ref _showObstacleGrid, value))
                {
                    OnGridVisualizationChanged();
                }
            }
        }

        /// <summary>
        /// 是否显示未知区域网格点
        /// </summary>
        public bool ShowUnknownGrid
        {
            get => _showUnknownGrid;
            set
            {
                if (SetProperty(ref _showUnknownGrid, value))
                {
                    OnGridVisualizationChanged();
                }
            }
        }

        /// <summary>
        /// 是否显示门网格点
        /// </summary>
        public bool ShowDoorGrid
        {
            get => _showDoorGrid;
            set
            {
                if (SetProperty(ref _showDoorGrid, value))
                {
                    OnGridVisualizationChanged();
                }
            }
        }

        /// <summary>
        /// 网格点类型
        /// </summary>
        public GridPointType GridPointType
        {
            get => _gridPointType;
            set
            {
                if (SetProperty(ref _gridPointType, value))
                {
                    OnPropertyChanged(nameof(IsRectanglePointType));
                    OnPropertyChanged(nameof(IsCirclePointType));
                    OnGridPointTypeChanged();
                }
            }
        }

        /// <summary>
        /// 是否使用立方体点类型
        /// </summary>
        public bool IsRectanglePointType
        {
            get => _gridPointType == GridPointType.Rectangle;
            set
            {
                if (value)
                {
                    GridPointType = GridPointType.Rectangle;
                }
            }
        }

        /// <summary>
        /// 是否使用圆形点类型
        /// </summary>
        public bool IsCirclePointType
        {
            get => _gridPointType == GridPointType.Circle;
            set
            {
                if (value)
                {
                    GridPointType = GridPointType.Circle;
                }
            }
        }

        /// <summary>
        /// 是否显示控制点连线（独立开关）
        /// </summary>
        public bool ShowControlVisualization
        {
            get => _showControlVisualization;
            set
            {
                if (SetProperty(ref _showControlVisualization, value))
                {
                    OnControlVisualizationChanged();
                }
            }
        }

        /// <summary>
        /// 是否显示路径线/地面连线（独立开关）
        /// </summary>
        public bool ShowPathLines
        {
            get => _showPathLines;
            set
            {
                // 吊装和空轨路径不能使用路径线
                if (value && !CanUsePathLines)
                {
                    LogManager.Warning("[路径可视化] 吊装和空轨路径不能使用路径线");
                    return;
                }
                if (SetProperty(ref _showPathLines, value))
                {
                    OnPathVisualizationModeChanged();
                }
            }
        }

        /// <summary>
        /// 是否显示通行空间（独立开关）
        /// </summary>
        public bool ShowObjectSpace
        {
            get => _showObjectSpace;
            set
            {
                if (SetProperty(ref _showObjectSpace, value))
                {
                    OnPathVisualizationModeChanged();
                }
            }
        }

        /// <summary>
        /// 当前路径是否可以使用路径线
        /// 地面路径可以使用路径线，吊装和空轨路径不能使用路径线
        /// </summary>
        public bool CanUsePathLines
        {
            get
            {
                if (SelectedPathRoute == null) return true;
                // 只有地面路径可以使用路径线
                return SelectedPathRoute.PathType == PathType.Ground;
            }
        }

        /// <summary>
        /// 是否使用标准连线模式（向后兼容，根据独立开关计算）
        /// </summary>
        public bool IsStandardLineMode
        {
            get => _showPathLines && !_showObjectSpace;
            set
            {
                if (value)
                {
                    ShowPathLines = true;
                    ShowObjectSpace = false;
                }
            }
        }

        /// <summary>
        /// 是否使用物体通行空间模式（向后兼容，等同于 ShowObjectSpace）
        /// </summary>
        public bool IsObjectSpaceMode
        {
            get => _showObjectSpace;
            set => ShowObjectSpace = value;
        }

        /// <summary>
        /// 是否使用带状连线模式（向后兼容，等同于 ShowPathLines）
        /// </summary>
        public bool IsRibbonLineMode
        {
            get => _showPathLines;
            set => ShowPathLines = value;
        }

        #endregion

        /// <summary>
        /// 路径策略选项集合
        /// </summary>
        public ObservableCollection<PathStrategyOption> PathStrategyOptions
        {
            get => _pathStrategyOptions;
        }

        /// <summary>
        /// 当前选择的路径策略
        /// </summary>
        public PathStrategyOption SelectedPathStrategy
        {
            get => _selectedPathStrategy;
            set
            {
                if (SetProperty(ref _selectedPathStrategy, value))
                {
                    OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                }
            }
        }

        public bool IsSelectingStartPoint
        {
            get => _isSelectingStartPoint;
            set => SetProperty(ref _isSelectingStartPoint, value);
        }

        public bool IsSelectingEndPoint
        {
            get => _isSelectingEndPoint;
            set => SetProperty(ref _isSelectingEndPoint, value);
        }

        #endregion


        public PathPlanningManager PathPlanningManager
        {
            get => _pathPlanningManager;
            set
            {
                if (_pathPlanningManager != value)
                {
                    // 取消旧的事件订阅
                    if (_pathPlanningManager != null)
                    {
                        UnsubscribeFromPathPlanningManager();
                    }

                    _pathPlanningManager = value;

                    // 订阅新的事件
                    if (_pathPlanningManager != null)
                    {
                        SubscribeToPathPlanningManager();
                    }
                }
            }
        }

        #endregion

        #region 命令

        public ICommand NewPathCommand { get; private set; }
        public ICommand NewRailPathCommand { get; private set; }
        public ICommand NewHoistingPathCommand { get; private set; }
        public ICommand NewMultiLevelHoistingPathCommand { get; private set; }
        public ICommand DuplicatePathCommand { get; private set; }
        public ICommand DeletePathCommand { get; private set; }
        public ICommand RenamePathCommand { get; private set; }
        public ICommand StartEditCommand { get; private set; }
        public ICommand EndEditCommand { get; private set; }
        public ICommand ClearPathCommand { get; private set; }
        public ICommand DeletePointCommand { get; private set; }
        public ICommand ModifyPointCommand { get; private set; }
        public ICommand CancelModifyPointCommand { get; private set; }
        public ICommand SelectStartPointCommand { get; private set; }
        public ICommand SelectEndPointCommand { get; private set; }
        public ICommand EditPointCoordinatesCommand { get; private set; }
        public ICommand AutoPlanPathCommand { get; private set; }
        public ICommand ClearAutoPathCommand { get; private set; }
        public ICommand ImportPathCommand { get; private set; }
        public ICommand ExportPathCommand { get; private set; }
        public ICommand SaveAsPathCommand { get; private set; }
        public ICommand CaptureAssemblyTerminalObjectForCreateCommand { get; private set; }
        public ICommand ReCaptureAssemblyTerminalObjectForEditCommand { get; private set; }
        public ICommand SelectAssemblyStartPointForCreateCommand { get; private set; }
        public ICommand RepositionRailStartPointCommand { get; private set; }
        public ICommand SelectAssemblyInstallationPointForCreateCommand { get; private set; }
        public ICommand SelectAssemblyInstallationPointForEditCommand { get; private set; }
        public ICommand ClearAssemblyReferenceRodCommand { get; private set; }
        public ICommand CancelRailAssemblyWorkflowCommand { get; private set; }
        public ICommand AnalyzeAssemblyTerminalFaceForCreateCommand { get; private set; }
        public ICommand AnalyzeAssemblyTerminalFaceForEditCommand { get; private set; }
        public ICommand DecreaseSelectedRailNormalOffsetCommand { get; private set; }
        public ICommand IncreaseSelectedRailNormalOffsetCommand { get; private set; }
        
        // 多层吊装命令
        public ICommand SelectMultiLevelStartPointCommand { get; private set; }
        public ICommand SelectMultiLevelEndPointCommand { get; private set; }
        public ICommand AddMultiLevelCommand { get; private set; }
        public ICommand DeleteMultiLevelCommand { get; private set; }
        public ICommand PickMultiLevelTargetCommand { get; private set; }
        public ICommand CreateMultiLevelPathCommand { get; private set; }
        public ICommand CancelMultiLevelHoistingCommand { get; private set; }

        #endregion

        #region Can Execute属性

        public bool CanExecuteAutoPlanPath => _hasStartPoint && _hasEndPoint &&
                                            ObjectLength > 0 && ObjectWidth > 0 && ObjectHeight > 0 &&
                                            SafetyMargin >= 0;

        public bool CanExecuteNewPath => !IsSelectingStartPoint && !IsSelectingEndPoint;

        public bool CanExecuteNewRailPath => !IsSelectingStartPoint && !IsSelectingEndPoint;

        public bool CanExecuteStartEdit => SelectedPathRoute != null &&
                                         (_pathPlanningManager?.PathEditState == PathEditState.Viewing);

        public bool CanExecuteEndEdit => (_pathPlanningManager?.PathEditState == PathEditState.Creating ||
                                        _pathPlanningManager?.PathEditState == PathEditState.Editing ||
                                        _pathPlanningManager?.PathEditState == PathEditState.AddingPoints ||
                                        _pathPlanningManager?.PathEditState == PathEditState.EditingPoint) ||
                                        CanCancelRailAssemblyWorkflow;

        public bool CanExecuteClearPath => SelectedPathRoute != null && SelectedPathRoute.Points.Count > 0;

        public bool CanExecuteExportPath => _pathPlanningManager?.Routes?.Count > 0 || SelectedPathRoute != null;

        public bool CanExecuteSaveAsPath => SelectedPathRoute != null && SelectedPathRoute.Points.Count > 0;
        public bool CanSelectAssemblyStartPointForCreate => HasAssemblyTerminalObject &&
                                                            _pathPlanningManager != null &&
                                                            AssemblyReferencePathManager.Instance.HasReferenceLine &&
                                                            !IsSelectingAssemblyStartPoint &&
                                                            !_isSelectingAssemblyEndFacePoints &&
                                                            !_isSelectingAssemblyInstallationPoint;
        public bool CanRepositionRailStartPoint => HasAssemblyTerminalObject &&
                                                   IsRailRouteSelected &&
                                                   SelectedPathRoute != null &&
                                                   _pathPlanningManager != null &&
                                                   AssemblyReferencePathManager.Instance.HasReferenceLine &&
                                                   !IsSelectingAssemblyStartPoint &&
                                                   !_isSelectingAssemblyEndFacePoints &&
                                                   !_isSelectingAssemblyInstallationPoint;
        public bool CanSelectAssemblyInstallationPointForCreate => HasAssemblyTerminalObject &&
                                                                   _pathPlanningManager != null &&
                                                                   !_isSelectingAssemblyStartPoint &&
                                                                   !_isSelectingAssemblyEndFacePoints &&
                                                                   !_isSelectingAssemblyInstallationPoint;
        public bool CanSelectAssemblyInstallationPointForEdit => HasAssemblyTerminalObject &&
                                                                 IsRailRouteSelected &&
                                                                 SelectedPathRoute != null &&
                                                                 _pathPlanningManager != null &&
                                                                 !_isSelectingAssemblyStartPoint &&
                                                                 !_isSelectingAssemblyEndFacePoints &&
                                                                 !_isSelectingAssemblyInstallationPoint;
        public bool CanAnalyzeAssemblyTerminalFaceForCreate => HasAssemblyTerminalObject &&
                                                               _pathPlanningManager != null &&
                                                               !IsSelectingAssemblyStartPoint &&
                                                               !IsSelectingAssemblyEndFacePoints &&
                                                               !_isSelectingAssemblyInstallationPoint;
        public bool CanAnalyzeAssemblyTerminalFaceForEdit => HasAssemblyTerminalObject &&
                                                             IsRailRouteSelected &&
                                                             SelectedPathRoute != null &&
                                                             _pathPlanningManager != null &&
                                                             !IsSelectingAssemblyStartPoint &&
                                                             !IsSelectingAssemblyEndFacePoints &&
                                                             !_isSelectingAssemblyInstallationPoint;

        public string CreateAssemblyInstallationPointButtonText => _hasAssemblyInstallationReference && !IsRailEditingWorkflowActive
            ? "重选安装点"
            : "选安装点";

        public string EditAssemblyInstallationPointButtonText => HasSelectedRailInstallationReference()
            ? "重选安装点"
            : "选安装点";

        public bool IsSelectingAssemblyEndFacePoints => _isSelectingAssemblyEndFacePoints;
        public bool CanCancelRailAssemblyWorkflow => _railAssemblyWorkflowMode != RailAssemblyWorkflowMode.None ||
                                                     HasAssemblyTerminalObject ||
                                                     _isSelectingAssemblyStartPoint ||
                                                     _isSelectingAssemblyEndFacePoints ||
                                                     _isSelectingAssemblyInstallationPoint ||
                                                     _hasAssemblyEndFaceAnalysis ||
                                                     _hasAssemblyInstallationReference;

        private bool IsRailCreateWorkflowActive => _railAssemblyWorkflowMode == RailAssemblyWorkflowMode.CreateNewRailPath;
        private bool IsRailEditingWorkflowActive => _railAssemblyWorkflowMode == RailAssemblyWorkflowMode.EditSelectedRail;

        private static bool IsRailAssemblyEditMode(RailAssemblyWorkflowMode workflowMode)
        {
            return workflowMode == RailAssemblyWorkflowMode.EditSelectedRail;
        }

        private static string GetRailAssemblyWorkflowLabel(RailAssemblyWorkflowMode workflowMode)
        {
            return IsRailAssemblyEditMode(workflowMode)
                ? "编辑现有Rail路径"
                : "新建Rail路径";
        }

        private bool ShouldShowAssemblyReferenceLineVisuals()
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                return false;
            }

            return IsRailEditingWorkflowActive || _hasAssemblyInstallationReference;
        }

        public bool CanExecuteModifyPoint => SelectedPathPoint != null &&
                                            _pathPlanningManager?.PathEditState != PathEditState.EditingPoint;
        public bool CanExecuteCancelModifyPoint => _pathPlanningManager?.PathEditState == PathEditState.EditingPoint;

        #endregion

        #region 构造函数

        /// <summary>
        /// 构造函数，需要传入主ViewModel以支持统一状态栏
        /// </summary>
        /// <param name="mainViewModel">主ViewModel，用于统一状态栏</param>
        public PathEditingViewModel(LogisticsControlViewModel mainViewModel) : base()
        {
            try
            {
                // 设置主ViewModel引用到基类
                SetMainViewModel(mainViewModel);

                _uiStateManager = UIStateManager.Instance;
                _pathDataManager = new PathDataManager();
                // 不在构造函数中创建PathPlanningManager，由外部设置
                _pathPlanningManager = null;

                if (_uiStateManager == null)
                {
                    throw new InvalidOperationException("UIStateManager初始化失败");
                }

                // PathPlanningManager将在外部设置，这里不需要检查

                // 初始化集合
                PathRoutes = new ObservableCollection<PathRouteViewModel>();

                // 初始化路径策略选项
                InitializePathStrategyOptions();
                InitializeRailConfigOptions();

                // 从配置加载参数
                LoadParametersFromConfig();

                // 订阅配置变更事件
                SubscribeToConfigChanges();

                // 初始化命令
                InitializeCommands();

                // 初始化物体参数同步（在PathPointRenderPlugin实例不为空时才同步）
                // 如果PathPointRenderPlugin尚未初始化，将在属性变更时自动同步
                SyncObjectParametersToRenderPlugin();

                // 注意：不在这里订阅PathPlanningManager事件，
                // 因为PathPlanningManager还没有设置，事件订阅在PathPlanningManager属性setter中处理

                LogManager.Info("PathEditingViewModel构造函数执行完成 - 支持统一状态栏");
            }
            catch (Exception ex)
            {
                LogManager.Error($"PathEditingViewModel构造函数异常: {ex.Message}", ex);
                UpdateMainStatus("初始化失败，请检查日志");
                throw;
            }
        }

        #endregion

        #region 初始化方法

        /// <summary>
        /// 初始化路径策略选项
        /// </summary>
        private void InitializePathStrategyOptions()
        {
            _pathStrategyOptions = new ObservableCollection<PathStrategyOption>
            {
                new PathStrategyOption
                {
                    Value = PathStrategy.Shortest,
                    DisplayName = "最短路径",
                    Description = "标准A*算法，选择路径总长度最短的路径"
                },
                new PathStrategyOption
                {
                    Value = PathStrategy.Straightest,
                    DisplayName = "直线优先",
                    Description = "优先选择主方向直线路径，减少转弯次数"
                },
                new PathStrategyOption
                {
                    Value = PathStrategy.SafestCenter,
                    DisplayName = "安全优先",
                    Description = "基于障碍物距离选择安全路径，适合大型物体居中行驶"
                }
            };

            // 默认选择最短路径策略（向后兼容）
            _selectedPathStrategy = _pathStrategyOptions.FirstOrDefault(x => x.Value == PathStrategy.Shortest);
        }

        /// <summary>
        /// 初始化 Rail 构型选项
        /// </summary>
        private void InitializeRailConfigOptions()
        {
            _railMountModeOptions = new ObservableCollection<RailConfigOption<RailMountMode>>
            {
                new RailConfigOption<RailMountMode>
                {
                    Value = RailMountMode.UnderRail,
                    DisplayName = "轨下安装",
                    Description = "安装头位于双轨下方，构件从轨道平面下侧连接"
                },
                new RailConfigOption<RailMountMode>
                {
                    Value = RailMountMode.OverRail,
                    DisplayName = "轨上安装",
                    Description = "安装头位于双轨上方，构件从轨道平面上侧连接"
                }
            };

        }

        private PathRoute GetSelectedCoreRoute()
        {
            if (_pathPlanningManager == null || SelectedPathRoute == null)
            {
                return null;
            }

            return _pathPlanningManager.Routes?.FirstOrDefault(route => route.Id == SelectedPathRoute.Id)
                ?? _pathPlanningManager.Routes?.FirstOrDefault(route => route.Name == SelectedPathRoute.Name);
        }

        private void ApplyRailRouteConfigurationChange(PathRoute coreRoute, string logMessage)
        {
            coreRoute.LastModified = DateTime.Now;

            SyncObjectParametersToRenderPlugin();
            _pathPlanningManager.DrawRouteVisualization(coreRoute, isAutoPath: false);
            _pathPlanningManager.SavePathToDatabase(coreRoute);
            _pathPlanningManager.RaiseVisualizationStateChanged();

            LogManager.Info($"[Rail构型] {coreRoute.Name}: {logMessage}");
        }

        private void SetRailAssemblyWorkflowMode(RailAssemblyWorkflowMode mode)
        {
            if (_railAssemblyWorkflowMode == mode)
            {
                return;
            }

            _railAssemblyWorkflowMode = mode;
            NotifyRailAssemblyCommandStateChanged();
        }

        private void NotifyRailAssemblyCommandStateChanged()
        {
            OnPropertyChanged(nameof(CanAnalyzeAssemblyTerminalFaceForCreate));
            OnPropertyChanged(nameof(CanAnalyzeAssemblyTerminalFaceForEdit));
            OnPropertyChanged(nameof(CanSelectAssemblyStartPointForCreate));
            OnPropertyChanged(nameof(CanRepositionRailStartPoint));
            OnPropertyChanged(nameof(CanSelectAssemblyInstallationPointForCreate));
            OnPropertyChanged(nameof(CanSelectAssemblyInstallationPointForEdit));
            OnPropertyChanged(nameof(CreateAssemblyInstallationPointButtonText));
            OnPropertyChanged(nameof(EditAssemblyInstallationPointButtonText));
            OnPropertyChanged(nameof(CanCancelRailAssemblyWorkflow));
            OnPropertyChanged(nameof(CanExecuteEndEdit));
        }

        private bool HasSelectedRailInstallationReference()
        {
            var coreRoute = GetSelectedCoreRoute();
            return coreRoute != null &&
                   coreRoute.PathType == PathType.Rail &&
                   coreRoute.RailPreferredNormal != null;
        }

        private int GetRoutePointIndexByType(PathRoute route, PathPointType pointType, int fallbackIndex)
        {
            if (route?.Points == null || route.Points.Count == 0)
            {
                return -1;
            }

            for (int i = 0; i < route.Points.Count; i++)
            {
                if (route.Points[i].Type == pointType)
                {
                    return i;
                }
            }

            return fallbackIndex >= 0 && fallbackIndex < route.Points.Count
                ? fallbackIndex
                : -1;
        }

        private bool IsAssemblyInstallationReferenceActiveForRoute(PathRoute route)
        {
            return route != null &&
                   route.PathType == PathType.Rail &&
                   _hasAssemblyInstallationReference &&
                   _assemblyInstallationAnchorPoint != null &&
                   !string.IsNullOrWhiteSpace(_assemblyInstallationReferenceRouteId) &&
                   string.Equals(_assemblyInstallationReferenceRouteId, route.Id, StringComparison.Ordinal);
        }

        private int GetRailRouteInstallationPointIndex(PathRoute route)
        {
            return GetRoutePointIndexByType(route, PathPointType.EndPoint, route?.Points?.Count - 1 ?? -1);
        }

        private int GetRailRouteStartPointIndex(PathRoute route)
        {
            return GetRoutePointIndexByType(route, PathPointType.StartPoint, 0);
        }

        private bool TryBuildRailRouteReferenceLine(PathRoute route, out AssemblyReferenceLine referenceLine)
        {
            referenceLine = null;
            if (route == null || route.PathType != PathType.Rail || route.Points == null || route.Points.Count < 2)
            {
                return false;
            }

            int startIndex = GetRailRouteStartPointIndex(route);
            int endIndex = GetRailRouteInstallationPointIndex(route);
            if (startIndex < 0 || endIndex < 0 || startIndex == endIndex)
            {
                return false;
            }

            Point3D startPoint = route.Points[startIndex].Position;
            Point3D endPoint = route.Points[endIndex].Position;
            Vector3D direction = new Vector3D(
                startPoint.X - endPoint.X,
                startPoint.Y - endPoint.Y,
                startPoint.Z - endPoint.Z);
            double lengthSquared = direction.X * direction.X + direction.Y * direction.Y + direction.Z * direction.Z;
            if (lengthSquared < 1e-9)
            {
                return false;
            }

            referenceLine = new AssemblyReferenceLine(startPoint, endPoint, direction.Normalize());
            return true;
        }

        private void RefreshSelectedRailReferenceLineVisuals(string statusMessage = null)
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                ClearAssemblyReferenceLineVisuals();
                return;
            }

            AssemblyReferenceLine referenceLine;

            if (IsRailEditingWorkflowActive)
            {
                // 编辑状态：使用默认杆长度构建参考线，方便选择更远的起点
                try
                {
                    referenceLine = BuildAssemblyReferenceLine();
                }
                catch
                {
                    ClearAssemblyReferenceLineVisuals();
                    return;
                }
            }
            else
            {
                // 非编辑状态：使用路径实际长度
                var coreRoute = GetSelectedCoreRoute();
                if (!TryBuildRailRouteReferenceLine(coreRoute, out referenceLine))
                {
                    ClearAssemblyReferenceLineVisuals();
                    return;
                }
            }

            AssemblyReferencePathManager.Instance.CreateOrUpdateReferenceRod(
                referenceLine.StartPoint,
                referenceLine.EndPoint,
                AssemblyReferenceRodDiameterInMeters);
            AssemblyStartPointText = $"({referenceLine.StartPoint.X:F2}, {referenceLine.StartPoint.Y:F2}, {referenceLine.StartPoint.Z:F2})";
            RefreshAssemblyTerminalObjectInfo(referenceLine.StartPoint, referenceLine.EndPoint);
            RenderAssemblyReferenceLine(referenceLine);
            NotifyRailAssemblyCommandStateChanged();

            if (!string.IsNullOrWhiteSpace(statusMessage))
            {
                UpdateMainStatus(statusMessage);
            }
        }

        private void PersistAssemblyInstallationReferenceToRailRoute(PathRoute route, string logMessage)
        {
            if (route == null)
            {
                throw new ArgumentNullException(nameof(route));
            }

            if (route.PathType != PathType.Rail)
            {
                throw new InvalidOperationException("只有 Rail 路径支持安装点参数更新。");
            }

            if (!_hasAssemblyInstallationReference || _assemblyInstallationAnchorPoint == null)
            {
                throw new InvalidOperationException("当前没有可应用的安装点参考。");
            }

            int installationPointIndex = GetRailRouteInstallationPointIndex(route);
            if (installationPointIndex < 0)
            {
                throw new InvalidOperationException("当前 Rail 路径没有可更新的终点。");
            }

            // 获取当前起点索引
            int startPointIndex = GetRailRouteStartPointIndex(route);
            if (startPointIndex < 0)
            {
                throw new InvalidOperationException("当前 Rail 路径没有可更新的起点。");
            }

            // 计算原路径长度（起点到终点的距离）
            Point3D currentStartPoint = route.Points[startPointIndex].Position;
            Point3D currentEndPoint = route.Points[installationPointIndex].Position;
            double pathLength = GeometryHelper.CalculatePointDistance(currentStartPoint, currentEndPoint);

            // 更新终点（安装点）
            if (!_pathPlanningManager.UpdatePathPointWithConstraints(route, installationPointIndex, _assemblyInstallationAnchorPoint))
            {
                throw new InvalidOperationException("更新 Rail 路径安装点失败。");
            }

            // 根据新终点和原路径长度重新计算起点位置
            Point3D newStartPoint = CalculateRailStartPointFromEndPoint(_assemblyInstallationAnchorPoint, pathLength);
            if (!_pathPlanningManager.UpdatePathPointWithConstraints(route, startPointIndex, newStartPoint))
            {
                throw new InvalidOperationException("更新 Rail 路径起点失败。");
            }

            route.RailPreferredNormal = CreatePersistedAssemblyPreferredNormal();
            route.RailNormalOffset = UnitsConverter.ConvertFromMeters(AssemblyAnchorVerticalOffsetInMeters);
            route.LastModified = DateTime.Now;
            _assemblyInstallationReferenceRouteId = route.Id;

            _pathPlanningManager.SavePathToDatabase(route);
            _pathPlanningManager.DrawRouteVisualization(route, isAutoPath: false);
            _pathPlanningManager.RaiseVisualizationStateChanged();

            if (SelectedPathRoute != null && SelectedPathRoute.Id == route.Id)
            {
                SyncPathViewModelFromCoreRoute(SelectedPathRoute, route, preserveSelection: true);
                OnPropertyChanged(nameof(SelectedRailNormalOffsetInMeters));
                NotifyRailAssemblyCommandStateChanged();
                RefreshAssemblyTerminalObjectInfo();
                RefreshSelectedRailInstallationReferenceVisuals();
                RefreshSelectedRailReferenceLineVisuals();
            }

            LogManager.Info($"[Rail构型] {route.Name}: {logMessage}，起点已同步更新为 ({newStartPoint.X:F3}, {newStartPoint.Y:F3}, {newStartPoint.Z:F3})");
        }

        private void RefreshSelectedRailInstallationReferenceVisuals()
        {
            var coreRoute = GetSelectedCoreRoute();
            if (!IsAssemblyInstallationReferenceActiveForRoute(coreRoute))
            {
                ClearAssemblyInstallationReferenceVisuals();
                return;
            }

            RenderAssemblyInstallationPickPoints(_assemblyInstallationSeedPoints);
            RenderAssemblyInstallationAnchorPoint(_assemblyInstallationAnchorPoint);
            RenderAssemblyInstallationCenterLine(_assemblyInstallationPickPoint, GetCurrentAssemblyOpticalAxisDirection());
            RenderAssemblyInstallationPlane(_assemblyInstallationAnchorPoint, GetCurrentAssemblyOpticalAxisDirection(), _assemblyInstallationPlaneSpanDirection);
        }

        private void AdjustSelectedRailNormalOffset(double deltaInMeters)
        {
            var coreRoute = GetSelectedCoreRoute();
            if (coreRoute == null || coreRoute.PathType != PathType.Rail)
            {
                return;
            }

            double currentOffsetInMeters = UnitsConverter.ConvertToMeters(coreRoute.RailNormalOffset);
            double nextOffsetInMeters = Math.Round(currentOffsetInMeters + deltaInMeters, 3);
            SelectedRailNormalOffsetInMeters = nextOffsetInMeters;
        }

        /// <summary>
        /// 从配置文件加载参数
        /// </summary>
        private void LoadParametersFromConfig()
        {
            try
            {
                var config = ConfigManager.Instance.Current;

                // 从 PathEditing 配置加载所有参数（使用米单位接口）
                _gridSize = config.PathEditing.CellSizeMeters;
                _objectLength = config.PathEditing.ObjectLengthMeters;
                _objectWidth = config.PathEditing.ObjectWidthMeters;
                _objectHeight = config.PathEditing.ObjectHeightMeters;
                _safetyMargin = config.PathEditing.SafetyMarginMeters;

                LogManager.Info($"从配置加载参数 - 物体: {_objectLength:F1}x{_objectWidth:F1}x{_objectHeight:F1}米, 安全间隙: {_safetyMargin:F2}米, 网格: {_gridSize:F1}米");
            }
            catch (Exception ex)
            {
                LogManager.Error($"加载配置参数失败: {ex.Message}", ex);
                // 使用默认值，不抛出异常
            }
        }

        #region 配置变更处理

        /// <summary>
        /// 订阅配置变更事件
        /// </summary>
        private void SubscribeToConfigChanges()
        {
            try
            {
                // 订阅特定类别的配置变更事件
                ConfigManager.Instance.CategoryConfigurationChanged += OnCategoryConfigurationChanged;
                LogManager.Info("PathEditingViewModel 已订阅配置变更事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"订阅配置变更事件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 取消订阅配置变更事件
        /// </summary>
        private void UnsubscribeFromConfigChanges()
        {
            try
            {
                ConfigManager.Instance.CategoryConfigurationChanged -= OnCategoryConfigurationChanged;
                LogManager.Info("PathEditingViewModel 已取消订阅配置变更事件");
            }
            catch (Exception ex)
            {
                LogManager.Warning($"取消订阅配置变更事件时发生异常: {ex.Message}");
            }
        }

        /// <summary>
        /// 配置变更事件处理
        /// </summary>
        private void OnCategoryConfigurationChanged(object sender, Tuple<ConfigCategory, ConfigurationChangedEventArgs> args)
        {
            try
            {
                var category = args.Item1;
                var eventArgs = args.Item2;

                // 只处理 PathEditing 相关的配置变更
                if (category == ConfigCategory.PathEditing || category == ConfigCategory.All)
                {
                    LogManager.Info($"收到 PathEditing 配置变更通知，正在更新参数...");

                    // 从配置重新加载参数
                    LoadParametersFromConfig();

                    // 触发属性变更通知，更新UI
                    OnPropertiesChanged(
                        nameof(ObjectLength),
                        nameof(ObjectWidth),
                        nameof(ObjectHeight),
                        nameof(SafetyMargin),
                        nameof(GridSize)
                    );

                    // 同步物体参数到渲染插件
                    SyncObjectParametersToRenderPlugin();

                    // 更新状态栏
                    string source = eventArgs.IsExternalChange ? "外部修改" : "内部更新";
                    UpdateMainStatus($"配置已更新 ({source}) - 物体参数: {ObjectLength:F1}x{ObjectWidth:F1}x{ObjectHeight:F1}米");

                    LogManager.Info($"PathEditing 配置参数已更新完成 - 来源: {source}");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"处理配置变更事件失败: {ex.Message}", ex);
            }
        }

        #endregion

        private void InitializeCommands()
        {
            NewPathCommand = new RelayCommand(async () => await ExecuteNewPathAsync(), () => CanExecuteNewPath);
            NewRailPathCommand = new RelayCommand(async () => await ExecuteNewRailPathAsync(), () => CanExecuteNewRailPath);
            NewHoistingPathCommand = new RelayCommand(async () => await ExecuteNewHoistingPathAsync());
            NewMultiLevelHoistingPathCommand = new RelayCommand(async () => await ExecuteNewMultiLevelHoistingPathAsync());
            SelectMultiLevelStartPointCommand = new RelayCommand(async () => await ExecuteSelectMultiLevelStartPointAsync());
            SelectMultiLevelEndPointCommand = new RelayCommand(async () => await ExecuteSelectMultiLevelEndPointAsync());
            AddMultiLevelCommand = new RelayCommand(() => ExecuteAddMultiLevel());
            DeleteMultiLevelCommand = new RelayCommand<HoistingLevelItem>((item) => ExecuteDeleteMultiLevel(item));
            PickMultiLevelTargetCommand = new RelayCommand<HoistingLevelItem>((item) => ExecutePickMultiLevelTarget(item));
            CreateMultiLevelPathCommand = new RelayCommand(async () => await ExecuteCreateMultiLevelPathAsync(), () => CanCreateMultiLevelPath);
            CancelMultiLevelHoistingCommand = new RelayCommand(() => ExecuteCancelMultiLevelHoisting());
            DuplicatePathCommand = new RelayCommand(async () => await ExecuteDuplicatePathAsync());
            DeletePathCommand = new RelayCommand(async () => await ExecuteDeletePathAsync());
            RenamePathCommand = new RelayCommand(async () => await ExecuteRenamePathAsync());
            StartEditCommand = new RelayCommand(async () => await ExecuteAddPathPointAsync(), () => CanExecuteStartEdit);
            EndEditCommand = new RelayCommand(async () => await ExecuteEndEditAsync(), () => CanExecuteEndEdit);
            ClearPathCommand = new RelayCommand(async () => await ExecuteClearPathAsync(), () => CanExecuteClearPath);
            DeletePointCommand = new RelayCommand<PathPointViewModel>(async (point) => await ExecuteDeletePointAsync(point));
            ModifyPointCommand = new RelayCommand(async () => await ExecuteModifyPointAsync(), () => CanExecuteModifyPoint);
            CancelModifyPointCommand = new RelayCommand(async () => await ExecuteCancelModifyPointAsync(), () => CanExecuteCancelModifyPoint);
            SelectStartPointCommand = new RelayCommand(async () => await ExecuteSelectStartPointAsync());
            SelectEndPointCommand = new RelayCommand(async () => await ExecuteSelectEndPointAsync());
            EditPointCoordinatesCommand = new RelayCommand<PathPointViewModel>(ExecuteEditPointCoordinates);
            AutoPlanPathCommand = new RelayCommand(async () => await ExecuteAutoPlanPathAsync(), () => CanExecuteAutoPlanPath);
            ClearAutoPathCommand = new RelayCommand(async () => await ExecuteClearAutoPathAsync());
            ImportPathCommand = new RelayCommand(async () => await ExecuteImportPathAsync());
            ExportPathCommand = new RelayCommand(async () => await ExecuteExportPathAsync(), () => CanExecuteExportPath);
            SaveAsPathCommand = new RelayCommand(async () => await ExecuteSaveAsPathAsync(), () => CanExecuteSaveAsPath);
            CaptureAssemblyTerminalObjectForCreateCommand = new RelayCommand(async () => await ExecuteCaptureAssemblyTerminalObjectAsync(RailAssemblyWorkflowMode.CreateNewRailPath));
            ReCaptureAssemblyTerminalObjectForEditCommand = new RelayCommand(async () => await ExecuteCaptureAssemblyTerminalObjectAsync(RailAssemblyWorkflowMode.EditSelectedRail));
            SelectAssemblyStartPointForCreateCommand = new RelayCommand(async () => await ExecuteSelectAssemblyStartPointAsync(), () => CanSelectAssemblyStartPointForCreate);
            RepositionRailStartPointCommand = new RelayCommand(async () => await ExecuteRepositionRailStartPointAsync(), () => CanRepositionRailStartPoint);
            SelectAssemblyInstallationPointForCreateCommand = new RelayCommand(async () => await ExecuteSelectAssemblyInstallationPointAsync(RailAssemblyWorkflowMode.CreateNewRailPath), () => CanSelectAssemblyInstallationPointForCreate);
            SelectAssemblyInstallationPointForEditCommand = new RelayCommand(async () => await ExecuteSelectAssemblyInstallationPointAsync(RailAssemblyWorkflowMode.EditSelectedRail), () => CanSelectAssemblyInstallationPointForEdit);
            ClearAssemblyReferenceRodCommand = new RelayCommand(() => ExecuteClearAssemblyReferenceRod());
            CancelRailAssemblyWorkflowCommand = new RelayCommand(() => ExecuteCancelRailAssemblyWorkflow(), () => CanCancelRailAssemblyWorkflow);
            AnalyzeAssemblyTerminalFaceForCreateCommand = new RelayCommand(async () => await ExecuteAnalyzeAssemblyTerminalFaceAsync(RailAssemblyWorkflowMode.CreateNewRailPath), () => CanAnalyzeAssemblyTerminalFaceForCreate);
            AnalyzeAssemblyTerminalFaceForEditCommand = new RelayCommand(async () => await ExecuteAnalyzeAssemblyTerminalFaceAsync(RailAssemblyWorkflowMode.EditSelectedRail), () => CanAnalyzeAssemblyTerminalFaceForEdit);
            DecreaseSelectedRailNormalOffsetCommand = new RelayCommand(() => AdjustSelectedRailNormalOffset(-RailNormalOffsetNudgeStepInMeters));
            IncreaseSelectedRailNormalOffsetCommand = new RelayCommand(() => AdjustSelectedRailNormalOffset(RailNormalOffsetNudgeStepInMeters));
        }

        #endregion

        #region 命令实现 - 从LogisticsControlViewModelcopy.cs迁移

        #region 路径管理命令

        private async Task ExecuteCaptureAssemblyTerminalObjectAsync(RailAssemblyWorkflowMode mode)
        {
            await SafeExecuteAsync(() =>
            {
                ClearNonGridPathVisualizations("[直线装配] 捕获箱体");

                var document = NavisApplication.ActiveDocument;
                var selectedItem = document?.CurrentSelection?.SelectedItems?.FirstOrDefault();
                if (selectedItem == null)
                {
                    throw new InvalidOperationException("请先在 Navisworks 中选择终点处已安装的箱体");
                }

                if (!ModelItemAnalysisHelper.IsModelItemValid(selectedItem))
                {
                    throw new InvalidOperationException("当前选择对象无效，请重新选择终点箱体");
                }

                SetRailAssemblyWorkflowMode(mode);

                _assemblyTerminalObject = selectedItem;
                _assemblyStartPoint = Point3D.Origin;
                HasAssemblyTerminalObject = true;
                AssemblyStartPointText = "未选择";
                AssemblyTerminalObjectName = ModelItemAnalysisHelper.GetSafeDisplayName(selectedItem);
                ResetAssemblyEndFaceAnalysisState();
                ResetAssemblyInstallationReferenceState();
                RefreshAssemblyTerminalObjectInfo();
                ClearAssemblyAnchorMarker();
                ClearAssemblyEndFaceAnalysisVisuals();
                ClearAssemblyInstallationReferenceVisuals();
                NotifyRailAssemblyCommandStateChanged();

                // 新建路径时隐藏其他路径的辅助线
                ClearAssemblyReferenceLineVisuals();

                UpdateMainStatus($"已捕获终点箱体: {AssemblyTerminalObjectName}");
                LogManager.Info($"[直线装配] 已捕获终点箱体: {AssemblyTerminalObjectName}");
            }, "捕获终点箱体");
        }

        private void ClearNonGridPathVisualizations(string context)
        {
            if (PathPointRenderPlugin.Instance == null)
            {
                return;
            }

            try
            {
                PathPointRenderPlugin.Instance.ClearPathsExcept(
                    "grid_visualization_all",
                    "grid_visualization_channel",
                    "grid_visualization_unknown",
                    "grid_visualization_obstacle",
                    "grid_visualization_door");
                LogManager.Info($"{context}：已清除现有路径可视化显示（保留网格可视化）");
            }
            catch (Exception ex)
            {
                LogManager.Error($"{context}：清除现有路径可视化失败: {ex.Message}", ex);
                throw;
            }
        }

        private async Task ExecuteSelectAssemblyStartPointAsync()
        {
            await SafeExecuteAsync(() =>
            {
                if (_pathPlanningManager == null)
                {
                    throw new InvalidOperationException("路径规划管理器未初始化，无法选择装配起点");
                }

                if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
                {
                    throw new InvalidOperationException("终点箱体未设置或已失效，请重新捕获终点箱体");
                }

                if (!AssemblyReferencePathManager.Instance.HasReferenceLine)
                {
                    throw new InvalidOperationException("请先选择安装点，系统生成终端安装辅助线后才能取起点");
                }

                BeginAssemblyStartPointSelection(
                    statusMessage: "请在辅助线附近点击一个起点，系统会自动吸附到辅助线上并生成直线路径",
                    logMessage: "[直线装配] 已进入起点拾取模式",
                    toolPluginFailureMessage: "ToolPlugin 初始化失败，请重试");
            }, "选择终端安装起点");
        }

        private async Task ExecuteRepositionRailStartPointAsync()
        {
            await SafeExecuteAsync(() =>
            {
                if (_pathPlanningManager == null)
                {
                    throw new InvalidOperationException("路径规划管理器未初始化，无法重选起点。");
                }

                if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
                {
                    throw new InvalidOperationException("终点箱体未设置或已失效，请先捕获终点箱体。");
                }

                var selectedRailRoute = GetSelectedCoreRoute();
                if (selectedRailRoute == null || selectedRailRoute.PathType != PathType.Rail)
                {
                    throw new InvalidOperationException("请先选中一条需要编辑起点的 Rail 路径。");
                }

                SetRailAssemblyWorkflowMode(RailAssemblyWorkflowMode.EditSelectedRail);
                RefreshSelectedRailReferenceLineVisuals();
                if (!AssemblyReferencePathManager.Instance.HasReferenceLine)
                {
                    throw new InvalidOperationException("当前 Rail 路径无法生成辅助线，请先检查路径起点和终点。");
                }

                BeginAssemblyStartPointSelection(
                    statusMessage: "请在辅助线附近点击新的起点位置，系统会自动吸附到辅助线上并更新当前 Rail 路径。",
                    logMessage: "[Rail构型] 已进入起点重选模式",
                    toolPluginFailureMessage: "ToolPlugin 初始化失败，请重试。");
            }, "重选 Rail 路径起点");
        }

        private void ExecuteClearAssemblyReferenceRod()
        {
            try
            {
                ClearAssemblyReferenceLineVisuals();
                ClearAssemblyEndFaceAnalysisVisuals();
                ClearAssemblyInstallationReferenceVisuals();
                UpdateMainStatus("已隐藏终端安装辅助线");
                LogManager.Info("[直线装配] 已隐藏辅助线");
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 隐藏辅助线失败: {ex.Message}");
            }
        }

        private async Task ExecuteAnalyzeAssemblyTerminalFaceAsync(RailAssemblyWorkflowMode workflowMode)
        {
            await SafeExecuteAsync(() =>
            {
                if (_pathPlanningManager == null)
                {
                    throw new InvalidOperationException("路径规划管理器未初始化，无法分析端面。");
                }

                if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
                {
                    throw new InvalidOperationException("终点箱体未设置或已失效，请先捕获终点箱体。");
                }

                PrepareRailAssemblyWorkflowForMode(
                    workflowMode,
                    editActionDescription: "请先选中一条需要编辑安装点的 Rail 路径。",
                    syncMountModeFromRoute: true);

                BeginAssemblyEndFaceSelection(workflowMode);
            }, "分析终端端面");
        }

        private async Task ExecuteSelectAssemblyInstallationPointAsync(RailAssemblyWorkflowMode workflowMode)
        {
            await SafeExecuteAsync(() =>
            {
                if (_pathPlanningManager == null)
                {
                    throw new InvalidOperationException("路径规划管理器未初始化，无法选择安装点。");
                }

                if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
                {
                    throw new InvalidOperationException("终点箱体未设置或已失效，请先捕获终点箱体。");
                }

                PrepareRailAssemblyWorkflowForMode(
                    workflowMode,
                    editActionDescription: "请先选中一条需要编辑安装点的 Rail 路径。",
                    syncMountModeFromRoute: false);

                BeginAssemblyInstallationSelection();
            }, "选择安装点");
        }

        private async void OnAssemblyReferenceMouseClicked(object sender, PickItemResult pickResult)
        {
            try
            {
                if (!IsSelectingAssemblyStartPoint || pickResult == null)
                {
                    return;
                }

                Point3D projectedStartPoint = AssemblyReferencePathManager.Instance.ProjectPointToReferenceLine(pickResult.Point);
                _assemblyStartPoint = projectedStartPoint;
                AssemblyStartPointText = $"({projectedStartPoint.X:F2}, {projectedStartPoint.Y:F2}, {projectedStartPoint.Z:F2})";
                LogManager.Info(
                    $"[直线装配] 点击点=({pickResult.Point.X:F2}, {pickResult.Point.Y:F2}, {pickResult.Point.Z:F2})，" +
                    $"投影起点=({projectedStartPoint.X:F2}, {projectedStartPoint.Y:F2}, {projectedStartPoint.Z:F2})");

                await SafeExecuteAsync(() =>
                {
                    ApplyAssemblyStartPointForCurrentWorkflow(projectedStartPoint);

                    CleanupAssemblyReferenceSelection();
                }, "生成终端安装路径");
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 处理起点拾取失败: {ex.Message}", ex);
                UpdateMainStatus($"终端安装起点拾取失败: {ex.Message}");
                CleanupAssemblyReferenceSelection();
            }
        }

        private async void OnAssemblyEndFaceMouseClicked(object sender, PickItemResult pickResult)
        {
            try
            {
                if (!_isSelectingAssemblyEndFacePoints || pickResult == null)
                {
                    return;
                }

                await SafeExecuteAsync(() =>
                {
                    if (!IsPickOnAssemblyTerminalObject(pickResult))
                    {
                        UpdateMainStatus("请点击当前终点箱体的同一个端面，不要点到其他对象。");
                        return;
                    }

                    _assemblyEndFaceSeedPoints.Add(pickResult.Point);
                    RenderAssemblyEndFaceSeedPoints();

                    int pickedCount = _assemblyEndFaceSeedPoints.Count;
                    LogManager.Info($"[直线装配] 已记录端面种子点 {pickedCount}: ({pickResult.Point.X:F3}, {pickResult.Point.Y:F3}, {pickResult.Point.Z:F3})");

                    if (pickedCount < 3)
                    {
                        UpdateMainStatus($"已记录端面点 {pickedCount}/3，请继续在同一端面平面上点击。");
                        return;
                    }

                    AnalyzeCurrentAssemblyEndFace();
                    CleanupAssemblyEndFaceSelection(clearVisuals: false);
                }, "处理端面三点拾取");
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 端面三点分析失败: {ex.Message}", ex);
                UpdateMainStatus($"端面三点分析失败: {ex.Message}");
                CleanupAssemblyEndFaceSelection(clearVisuals: false);
            }
        }

        private async void OnAssemblyInstallationMouseClicked(object sender, PickItemResult pickResult)
        {
            try
            {
                if (!_isSelectingAssemblyInstallationPoint || pickResult == null)
                {
                    return;
                }

                await SafeExecuteAsync(() =>
                {
                    if (!IsPickOnAssemblyTerminalObject(pickResult))
                    {
                        UpdateMainStatus("请点击当前终点箱体表面，不要点到其他对象。");
                        return;
                    }

                    _assemblyInstallationSeedPoints.Add(pickResult.Point);
                    RenderAssemblyInstallationPickPoints(_assemblyInstallationSeedPoints);

                    int pickedCount = _assemblyInstallationSeedPoints.Count;
                    LogManager.Info($"[直线装配] 已记录安装面点 {pickedCount}: ({pickResult.Point.X:F3}, {pickResult.Point.Y:F3}, {pickResult.Point.Z:F3})");

                    if (pickedCount < 2)
                    {
                        UpdateMainStatus("已记录安装面点 1/2，请继续在同一安装面上点击第二个点。");
                        return;
                    }

                    BuildAndRenderAssemblyInstallationReference(
                        _assemblyInstallationSeedPoints[0],
                        _assemblyInstallationSeedPoints[1]);

                    ApplyAssemblyInstallationReferenceForCurrentWorkflow();
                    CleanupAssemblyInstallationSelection(clearVisuals: false);
                }, "处理安装点拾取");
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 安装点计算失败: {ex.Message}", ex);
                UpdateMainStatus($"安装点计算失败: {ex.Message}");
                CleanupAssemblyInstallationSelection(clearVisuals: true);
            }
        }

        private void PrepareRailAssemblyWorkflowForMode(
            RailAssemblyWorkflowMode workflowMode,
            string editActionDescription,
            bool syncMountModeFromRoute)
        {
            PathRoute selectedRailRoute = null;
            if (IsRailAssemblyEditMode(workflowMode))
            {
                selectedRailRoute = RequireSelectedRailRouteForAssemblyEdit(editActionDescription);
                if (syncMountModeFromRoute)
                {
                    AssemblyMountMode = selectedRailRoute.RailMountMode;
                }
            }

            SetRailAssemblyWorkflowMode(workflowMode);
        }

        private PathRoute RequireSelectedRailRouteForAssemblyEdit(string errorMessage)
        {
            var selectedRailRoute = GetSelectedCoreRoute();
            if (selectedRailRoute == null || selectedRailRoute.PathType != PathType.Rail)
            {
                throw new InvalidOperationException(errorMessage);
            }

            return selectedRailRoute;
        }

        private void BeginAssemblyStartPointSelection(string statusMessage, string logMessage, string toolPluginFailureMessage)
        {
            CleanupAssemblyReferenceSelection();

            _pathPlanningManager.DisableMouseHandling();
            IsSelectingAssemblyStartPoint = true;
            NotifyRailAssemblyCommandStateChanged();

            PathClickToolPlugin.MouseClicked -= OnAssemblyReferenceMouseClicked;
            PathClickToolPlugin.MouseClicked += OnAssemblyReferenceMouseClicked;

            if (!ForceReinitializeToolPlugin(subscribeToEvents: false))
            {
                CleanupAssemblyReferenceSelection();
                throw new InvalidOperationException(toolPluginFailureMessage);
            }

            _pathPlanningManager.StartClickTool(PathPointType.StartPoint);
            UpdateMainStatus(statusMessage);
            LogManager.Info(logMessage);
        }

        private void BeginAssemblyEndFaceSelection(RailAssemblyWorkflowMode workflowMode)
        {
            CleanupAssemblyReferenceSelection();
            CleanupAssemblyEndFaceSelection(clearVisuals: false);
            CleanupAssemblyInstallationSelection();
            ClearAssemblyEndFaceAnalysisVisuals();
            ResetAssemblyEndFaceAnalysisState();
            ClearAssemblyInstallationReferenceVisuals();
            ResetAssemblyInstallationReferenceState();
            _assemblyEndFaceSeedPoints.Clear();

            _pathPlanningManager.DisableMouseHandling();
            _isSelectingAssemblyEndFacePoints = true;
            NotifyRailAssemblyCommandStateChanged();

            PathClickToolPlugin.MouseClicked -= OnAssemblyEndFaceMouseClicked;
            PathClickToolPlugin.MouseClicked += OnAssemblyEndFaceMouseClicked;

            if (!ForceReinitializeToolPlugin(subscribeToEvents: false))
            {
                CleanupAssemblyEndFaceSelection(clearVisuals: false);
                throw new InvalidOperationException("ToolPlugin 初始化失败，请重试。");
            }

            UpdateMainStatus("请在同一个端面平面上连续点击 3 个点，系统将分析端面中心。");
            LogManager.Info($"[直线装配] 已进入端面三点分析模式，模式={GetRailAssemblyWorkflowLabel(workflowMode)}");
        }

        private void BeginAssemblyInstallationSelection()
        {
            CleanupAssemblyReferenceSelection();
            CleanupAssemblyEndFaceSelection(clearVisuals: false);
            CleanupAssemblyInstallationSelection();
            ClearAssemblyInstallationReferenceVisuals();

            _pathPlanningManager.DisableMouseHandling();
            _isSelectingAssemblyInstallationPoint = true;
            NotifyRailAssemblyCommandStateChanged();

            PathClickToolPlugin.MouseClicked -= OnAssemblyInstallationMouseClicked;
            PathClickToolPlugin.MouseClicked += OnAssemblyInstallationMouseClicked;

            if (!ForceReinitializeToolPlugin(subscribeToEvents: false))
            {
                CleanupAssemblyInstallationSelection();
                throw new InvalidOperationException("ToolPlugin 初始化失败，请重试。");
            }

            _assemblyInstallationSeedPoints.Clear();
            UpdateMainStatus("请在终点箱体表面连续点击两个安装面点，系统将按两点和光轴计算安装参考面与安装点。");
            LogManager.Info($"[直线装配] 已进入安装点拾取模式，模式={GetRailAssemblyWorkflowLabel(_railAssemblyWorkflowMode)}");
        }

        private void ApplyAssemblyStartPointForCurrentWorkflow(Point3D projectedStartPoint)
        {
            if (IsRailEditingWorkflowActive)
            {
                UpdateSelectedRailRouteStartPoint(projectedStartPoint);
                ClearAssemblyReferenceLineVisuals();
                UpdateMainStatus("已根据辅助线更新当前 Rail 路径起点");
                return;
            }

            CreateAssemblyLinearRoute(projectedStartPoint);
            UpdateMainStatus("已根据辅助线起点生成终端安装路径");
        }

        private void ApplyAssemblyInstallationReferenceForCurrentWorkflow()
        {
            if (IsRailEditingWorkflowActive)
            {
                var selectedRailRoute = RequireSelectedRailRouteForAssemblyEdit("当前没有可更新安装点的 Rail 路径。");
                PersistAssemblyInstallationReferenceToRailRoute(
                    selectedRailRoute,
                    "已重选安装点并同步更新 Rail 路径安装参数");
                return;
            }

            LogManager.Info("[直线装配] 安装点已确定，请继续选择起点以生成新路径");
        }

        private void CreateAssemblyLinearRoute(Point3D startPoint)
        {
            Point3D endPoint = AssemblyReferencePathManager.Instance.ReferenceLineEnd;
            string routeName = $"人工_{DateTime.Now:MMdd_HHmmss}";

            var route = new PathRoute(routeName)
            {
                Description = $"直线装配路径 - {AssemblyTerminalObjectName}",
                PathType = PathType.Rail,
                RailMountMode = AssemblyMountMode,
                RailPathDefinitionMode = RailPathDefinitionMode.RailCenterLine,
                RailNormalOffset = UnitsConverter.ConvertFromMeters(AssemblyAnchorVerticalOffsetInMeters)
            };

            if (_hasAssemblyInstallationReference)
            {
                route.RailPreferredNormal = CreatePersistedAssemblyPreferredNormal();
            }

            route.AddPoint(new PathPoint(startPoint, "起点", PathPointType.StartPoint));
            route.AddPoint(new PathPoint(endPoint, "装配终点", PathPointType.EndPoint));

            if (!_pathPlanningManager.AddRoute(route))
            {
                throw new InvalidOperationException("装配路径添加失败");
            }

            _pathPlanningManager.SetCurrentRoute(route);
            if (!_pathPlanningManager.GeneratePath(route))
            {
                throw new InvalidOperationException("装配路径生成失败");
            }

            if (!_pathPlanningManager.FinishEditing())
            {
                throw new InvalidOperationException("装配路径完成编辑失败");
            }

            var generatedRouteViewModel = PathRoutes.FirstOrDefault(p => p.Name == route.Name);
            if (generatedRouteViewModel != null)
            {
                SelectedPathRoute = generatedRouteViewModel;
                UpdatePassageSpaceVisualizationForPathType(route.PathType);
            }

            HideAssemblyReferenceVisuals(
                resetStartPointText: false,
                statusMessage: null,
                logMessage: "[直线装配] 路径生成完成后已隐藏辅助线可视化");

            AssemblyTerminalObjectInfo = string.Format(
                "对接终点=({0:F2}, {1:F2}, {2:F2})，装配起点={3}，安装方式={4}，对接基准={5}",
                endPoint.X,
                endPoint.Y,
                endPoint.Z,
                AssemblyStartPointText,
                AssemblyMountMode == RailMountMode.OverRail ? "轨上安装" : "轨下安装",
                GetAssemblyAnchorText());

            OnPropertyChanged(nameof(PathRoutes));
            LogManager.Info(
                $"[直线装配] 已生成并完成路径: {route.Name}，起点=({startPoint.X:F2}, {startPoint.Y:F2}, {startPoint.Z:F2})，终点=({endPoint.X:F2}, {endPoint.Y:F2}, {endPoint.Z:F2})" +
                $"{(route.RailPreferredNormal != null ? $"，安装法向=({route.RailPreferredNormal.X:F3}, {route.RailPreferredNormal.Y:F3}, {route.RailPreferredNormal.Z:F3})" : string.Empty)}");
        }

        private void UpdateSelectedRailRouteStartPoint(Point3D startPoint)
        {
            var route = GetSelectedCoreRoute();
            if (route == null || route.PathType != PathType.Rail)
            {
                throw new InvalidOperationException("当前没有可更新起点的 Rail 路径。");
            }

            int startPointIndex = GetRailRouteStartPointIndex(route);
            if (startPointIndex < 0)
            {
                throw new InvalidOperationException("当前 Rail 路径没有可更新的起点。");
            }

            if (!_pathPlanningManager.UpdatePathPointWithConstraints(route, startPointIndex, startPoint))
            {
                throw new InvalidOperationException("更新 Rail 路径起点失败。");
            }

            route.LastModified = DateTime.Now;
            _pathPlanningManager.SavePathToDatabase(route);
            _pathPlanningManager.DrawRouteVisualization(route, isAutoPath: false);
            _pathPlanningManager.RaiseVisualizationStateChanged();

            if (SelectedPathRoute != null && SelectedPathRoute.Id == route.Id)
            {
                SyncPathViewModelFromCoreRoute(SelectedPathRoute, route, preserveSelection: true);
                RefreshSelectedRailReferenceLineVisuals();
            }

            LogManager.Info($"[Rail构型] {route.Name}: 已重选起点为 ({startPoint.X:F3}, {startPoint.Y:F3}, {startPoint.Z:F3})");
        }

        private void HideAssemblyReferenceVisuals(bool resetStartPointText, string statusMessage, string logMessage)
        {
            CleanupAssemblyReferenceSelection();
            CleanupAssemblyEndFaceSelection(clearVisuals: false);
            ClearAssemblyReferenceLineVisuals();
            ClearAssemblyEndFaceAnalysisVisuals();
            ClearAssemblyInstallationReferenceVisuals();
            if (resetStartPointText)
            {
                AssemblyStartPointText = "未选择";
            }
            NotifyRailAssemblyCommandStateChanged();
            if (!string.IsNullOrWhiteSpace(statusMessage))
            {
                UpdateMainStatus(statusMessage);
            }

            if (!string.IsNullOrWhiteSpace(logMessage))
            {
                LogManager.Info(logMessage);
            }
        }

        private void ResetRailAssemblyWorkflowState(bool announce, string statusMessage = null, string logMessage = null)
        {
            CleanupAssemblyReferenceSelection();
            CleanupAssemblyEndFaceSelection(clearVisuals: true);
            CleanupAssemblyInstallationSelection(clearVisuals: true);
            ClearAssemblyReferenceLineVisuals();
            ClearAssemblyEndFaceAnalysisVisuals();
            ClearAssemblyInstallationReferenceVisuals();
            ResetAssemblyEndFaceAnalysisState();
            ResetAssemblyInstallationReferenceState();
            _railAssemblyContext.ResetSession();
            HasAssemblyTerminalObject = false;
            AssemblyTerminalObjectName = _assemblyTerminalObjectName;
            AssemblyTerminalObjectInfo = _assemblyTerminalObjectInfo;
            AssemblyStartPointText = _assemblyStartPointText;

            SetRailAssemblyWorkflowMode(RailAssemblyWorkflowMode.None);
            NotifyRailAssemblyCommandStateChanged();

            if (announce && !string.IsNullOrWhiteSpace(statusMessage))
            {
                UpdateMainStatus(statusMessage);
            }

            if (!string.IsNullOrWhiteSpace(logMessage))
            {
                LogManager.Info(logMessage);
            }
        }

        private void ExecuteCancelRailAssemblyWorkflow()
        {
            try
            {
                ResetRailAssemblyWorkflowState(
                    announce: true,
                    statusMessage: "已取消 Rail 装配流程",
                    logMessage: "[直线装配] 已取消 Rail 装配流程并清理状态");
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 取消 Rail 装配流程失败: {ex.Message}", ex);
                UpdateMainStatus($"取消 Rail 装配流程失败: {ex.Message}");
            }
        }

        private Point3D GetAssemblyTerminalAnchorPoint()
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                throw new InvalidOperationException("终点箱体未设置或已失效，无法计算对接点");
            }

            if (_hasAssemblyInstallationReference && _assemblyInstallationAnchorPoint != null)
            {
                return _assemblyInstallationAnchorPoint;
            }

            HostCoordinateAdapter adapter = CoordinateSystemManager.Instance.CreateHostAdapter();
            ProjectReferenceFrame projectFrame = CreateAssemblyProjectReferenceFrame(adapter);

            var bounds = _assemblyTerminalObject.BoundingBox();
            Point3D canonicalCenter = adapter.ToCanonicalPoint(bounds.Center);
            Vector3D canonicalUp = adapter.ToCanonicalVector(
                ModelItemTransformHelper.GetDirectionFromTransform(
                    _assemblyTerminalObject.Transform,
                    projectFrame.DefaultModelAxisConvention.UpAxis));
            double direction = GetAssemblyAnchorDirection();
            double verticalOffset = UnitsConverter.ConvertFromMeters(AssemblyAnchorVerticalOffsetInMeters);

            Point3D canonicalAnchorPoint = new Point3D(
                canonicalCenter.X + canonicalUp.X * verticalOffset * direction,
                canonicalCenter.Y + canonicalUp.Y * verticalOffset * direction,
                canonicalCenter.Z + canonicalUp.Z * verticalOffset * direction);

            return adapter.FromCanonicalPoint(canonicalAnchorPoint);
        }

        /// <summary>
        /// 根据 Rail 路径终点和路径长度计算起点位置。
        /// 起点位于从终点沿光轴方向（远离球心方向）延伸路径长度的位置。
        /// </summary>
        private Point3D CalculateRailStartPointFromEndPoint(Point3D endPoint, double pathLength)
        {
            HostCoordinateAdapter adapter = CoordinateSystemManager.Instance.CreateHostAdapter();
            ProjectReferenceFrame projectFrame = CreateAssemblyProjectReferenceFrame(adapter);

            Point3D opticalAxisReferencePoint = GetAssemblyOpticalAxisReferencePoint();
            Point3D canonicalEndPoint = adapter.ToCanonicalPoint(endPoint);
            Point3D canonicalOpticalAxisRef = adapter.ToCanonicalPoint(opticalAxisReferencePoint);

            // 计算从球心到光轴参考点的方向（作为参考线方向）
            Vector3D direction = new Vector3D(
                canonicalOpticalAxisRef.X - projectFrame.SphereCenterInCanonical.X,
                canonicalOpticalAxisRef.Y - projectFrame.SphereCenterInCanonical.Y,
                canonicalOpticalAxisRef.Z - projectFrame.SphereCenterInCanonical.Z);

            direction = direction.Normalize();

            // 起点 = 终点 + 方向 * 路径长度
            Point3D canonicalStartPoint = new Point3D(
                canonicalEndPoint.X + direction.X * pathLength,
                canonicalEndPoint.Y + direction.Y * pathLength,
                canonicalEndPoint.Z + direction.Z * pathLength);

            return adapter.FromCanonicalPoint(canonicalStartPoint);
        }

        private void UpdateAssemblyInstallationAnchorFromVerticalOffset()
        {
            if (!_hasAssemblyInstallationReference ||
                _assemblyInstallationBaseAnchorPoint == null)
            {
                return;
            }

            double offset = UnitsConverter.ConvertFromMeters(_assemblyAnchorVerticalOffsetInMeters);
            _assemblyInstallationAnchorPoint = new Point3D(
                _assemblyInstallationBaseAnchorPoint.X + _assemblyInstallationPlaneNormal.X * (float)offset,
                _assemblyInstallationBaseAnchorPoint.Y + _assemblyInstallationPlaneNormal.Y * (float)offset,
                _assemblyInstallationBaseAnchorPoint.Z + _assemblyInstallationPlaneNormal.Z * (float)offset);

            if (_hasAssemblyInstallationReference)
            {
                RenderAssemblyInstallationPickPoints(_assemblyInstallationSeedPoints);
                RenderAssemblyInstallationAnchorPoint(_assemblyInstallationAnchorPoint);
                RenderAssemblyInstallationCenterLine(_assemblyInstallationPickPoint, GetCurrentAssemblyOpticalAxisDirection());
                RenderAssemblyInstallationPlane(_assemblyInstallationAnchorPoint, GetCurrentAssemblyOpticalAxisDirection(), _assemblyInstallationPlaneSpanDirection);
            }
            else
            {
                ClearAssemblyInstallationReferenceVisuals();
            }
        }

        private Point3D CreatePersistedAssemblyPreferredNormal()
        {
            HostCoordinateAdapter adapter = CoordinateSystemManager.Instance.CreateHostAdapter();
            Vector3 normalizedPreferredNormal = RailPathPoseHelper.NormalizePreferredNormalToHostUpHemisphere(
                _assemblyInstallationPlaneNormal,
                adapter.HostUpVector3);

            return new Point3D(
                normalizedPreferredNormal.X,
                normalizedPreferredNormal.Y,
                normalizedPreferredNormal.Z);
        }

        private Vector3 GetCurrentAssemblyOpticalAxisDirection()
        {
            Point3D opticalAxisReferencePoint = GetAssemblyOpticalAxisReferencePoint();
            Point3D sphereCenterPoint = new Point3D(
                AssemblySphereCenterX,
                AssemblySphereCenterY,
                AssemblySphereCenterZ);

            Vector3 opticalAxisDirection = new Vector3(
                (float)(opticalAxisReferencePoint.X - sphereCenterPoint.X),
                (float)(opticalAxisReferencePoint.Y - sphereCenterPoint.Y),
                (float)(opticalAxisReferencePoint.Z - sphereCenterPoint.Z));
            return Vector3.Normalize(opticalAxisDirection);
        }

        private Point3D GetAssemblyOpticalAxisReferencePoint()
        {
            if (_hasAssemblyEndFaceAnalysis && _assemblyEndFaceCenterPoint != null)
            {
                return _assemblyEndFaceCenterPoint;
            }

            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                throw new InvalidOperationException("终点箱体未设置或已失效，无法计算光轴参考点");
            }

            return _assemblyTerminalObject.BoundingBox().Center;
        }

        private AssemblyReferenceLine BuildAssemblyReferenceLine()
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                throw new InvalidOperationException("终点箱体未设置或已失效，无法生成装配参考线");
            }

            HostCoordinateAdapter adapter = CoordinateSystemManager.Instance.CreateHostAdapter();
            ProjectReferenceFrame projectFrame = CreateAssemblyProjectReferenceFrame(adapter);

            Point3D opticalAxisReferencePoint = GetAssemblyOpticalAxisReferencePoint();
            Point3D endPoint = GetAssemblyTerminalAnchorPoint();

            Point3D canonicalAxisReferencePoint = adapter.ToCanonicalPoint(opticalAxisReferencePoint);
            Point3D canonicalEndPoint = adapter.ToCanonicalPoint(endPoint);
            Vector3D direction = new Vector3D(
                canonicalAxisReferencePoint.X - projectFrame.SphereCenterInCanonical.X,
                canonicalAxisReferencePoint.Y - projectFrame.SphereCenterInCanonical.Y,
                canonicalAxisReferencePoint.Z - projectFrame.SphereCenterInCanonical.Z);
            double directionLengthSquared = direction.X * direction.X + direction.Y * direction.Y + direction.Z * direction.Z;
            if (directionLengthSquared < 1e-9)
            {
                throw new InvalidOperationException("光轴参考点与项目球心重合，无法生成装配参考线方向");
            }

            direction = direction.Normalize();
            double rodLength = UnitsConverter.ConvertFromMeters(AssemblyReferenceRodLengthInMeters);
            Point3D canonicalStartPoint = new Point3D(
                canonicalEndPoint.X + direction.X * rodLength,
                canonicalEndPoint.Y + direction.Y * rodLength,
                canonicalEndPoint.Z + direction.Z * rodLength);
            Point3D startPoint = adapter.FromCanonicalPoint(canonicalStartPoint);

            LogManager.Info(
                $"[直线装配] 参考线已计算，终点锚点=({endPoint.X:F2}, {endPoint.Y:F2}, {endPoint.Z:F2}), " +
                $"光轴参考点=({opticalAxisReferencePoint.X:F2}, {opticalAxisReferencePoint.Y:F2}, {opticalAxisReferencePoint.Z:F2}), " +
                $"参考线外端=({startPoint.X:F2}, {startPoint.Y:F2}, {startPoint.Z:F2}), " +
                $"球心到光轴参考点方向(内部坐标)=({direction.X:F3}, {direction.Y:F3}, {direction.Z:F3})");

            return new AssemblyReferenceLine(startPoint, endPoint, direction);
        }

        private void RefreshAssemblyTerminalObjectInfo(Point3D referenceStartPoint = null, Point3D referenceEndPoint = null)
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                return;
            }

            var bounds = _assemblyTerminalObject.BoundingBox();
            string anchorText = GetAssemblyAnchorText();
            string mountText = AssemblyMountMode == RailMountMode.OverRail ? "轨上安装" : "轨下安装";
            Point3D opticalAxisReferencePoint = GetAssemblyOpticalAxisReferencePoint();
            string opticalAxisText = _hasAssemblyEndFaceAnalysis
                ? string.Format("端面中心=({0:F2}, {1:F2}, {2:F2})", opticalAxisReferencePoint.X, opticalAxisReferencePoint.Y, opticalAxisReferencePoint.Z)
                : string.Format("箱体中心=({0:F2}, {1:F2}, {2:F2})", opticalAxisReferencePoint.X, opticalAxisReferencePoint.Y, opticalAxisReferencePoint.Z);
            string anchorPointText = _hasAssemblyInstallationReference
                ? string.Format("{0}点=({1:F2}, {2:F2}, {3:F2})",
                    anchorText,
                    _assemblyInstallationAnchorPoint.X,
                    _assemblyInstallationAnchorPoint.Y,
                    _assemblyInstallationAnchorPoint.Z)
                : string.Format("{0}点=未选择", anchorText);
            string installationText = _hasAssemblyInstallationReference
                ? string.Format(
                    "安装面点中点=({0:F2}, {1:F2}, {2:F2})，安装点=({3:F2}, {4:F2}, {5:F2})，偏距={6:F3}m",
                    _assemblyInstallationPickPoint.X,
                    _assemblyInstallationPickPoint.Y,
                    _assemblyInstallationPickPoint.Z,
                    _assemblyInstallationAnchorPoint.X,
                    _assemblyInstallationAnchorPoint.Y,
                    _assemblyInstallationAnchorPoint.Z,
                    _assemblyInstallationOffsetDistanceInMeters)
                : "安装点=未选择";

            if (referenceStartPoint != null && referenceEndPoint != null)
            {
                AssemblyTerminalObjectInfo = string.Format(
                    "中心=({0:F2}, {1:F2}, {2:F2})，尺寸=({3:F2}, {4:F2}, {5:F2})，{6}，{7}，{8}，{9}，垂直偏移={10:F3}m，辅助线外端=({11:F2}, {12:F2}, {13:F2})",
                    bounds.Center.X,
                    bounds.Center.Y,
                    bounds.Center.Z,
                    bounds.Max.X - bounds.Min.X,
                    bounds.Max.Y - bounds.Min.Y,
                    bounds.Max.Z - bounds.Min.Z,
                    mountText,
                    anchorPointText,
                    opticalAxisText,
                    installationText,
                    AssemblyAnchorVerticalOffsetInMeters,
                    referenceStartPoint.X,
                    referenceStartPoint.Y,
                    referenceStartPoint.Z);
                return;
            }

            AssemblyTerminalObjectInfo = string.Format(
                "中心=({0:F2}, {1:F2}, {2:F2})，尺寸=({3:F2}, {4:F2}, {5:F2})，{6}，{7}，{8}，{9}，垂直偏移={10:F3}m",
                bounds.Center.X,
                bounds.Center.Y,
                bounds.Center.Z,
                bounds.Max.X - bounds.Min.X,
                bounds.Max.Y - bounds.Min.Y,
                bounds.Max.Z - bounds.Min.Z,
                mountText,
                anchorPointText,
                opticalAxisText,
                installationText,
                AssemblyAnchorVerticalOffsetInMeters);
        }

        private void RefreshAssemblyReferenceRodIfNeeded()
        {
            if (!ShouldShowAssemblyReferenceLineVisuals())
            {
                ClearAssemblyReferenceLineVisuals();
                return;
            }

            if (_assemblyTerminalObject == null)
            {
                return;
            }

            try
            {
                AssemblyReferenceLine referenceLine = BuildAssemblyReferenceLine();

                AssemblyReferencePathManager.Instance.CreateOrUpdateReferenceRod(
                    referenceLine.StartPoint,
                    referenceLine.EndPoint,
                    AssemblyReferenceRodDiameterInMeters);

                RefreshAssemblyTerminalObjectInfo(referenceLine.StartPoint, referenceLine.EndPoint);
                RenderAssemblyAnchorMarker();
                RenderAssemblyCenterGuideLine();
                RenderAssemblyReferenceLine(referenceLine);
                NotifyRailAssemblyCommandStateChanged();
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 刷新参考杆失败: {ex.Message}", ex);
            }
        }

        private void InitializeAssemblyAnchorVerticalOffsetFromTerminalObject()
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                return;
            }

            HostCoordinateAdapter adapter = CoordinateSystemManager.Instance.CreateHostAdapter();
            ProjectReferenceFrame projectFrame = CreateAssemblyProjectReferenceFrame(adapter);
            var bounds = _assemblyTerminalObject.BoundingBox();
            double suggestedOffset = UnitsConverter.ConvertToMeters(
                Math.Max(0.0, projectFrame.DefaultModelAxisConvention.GetUpSize(bounds) / 2.0));
            _assemblyAnchorVerticalOffsetInMeters = suggestedOffset;
            OnPropertyChanged(nameof(AssemblyAnchorVerticalOffsetInMeters));
        }

        private double GetAssemblyAnchorDirection()
        {
            return PathRoute.IsTopPayloadAnchorForMountMode(AssemblyMountMode)
                ? 1.0
                : -1.0;
        }

        private string GetAssemblyAnchorText()
        {
            return PathRoute.IsTopPayloadAnchorForMountMode(AssemblyMountMode)
                ? "顶面对接"
                : "底面对接";
        }

        private sealed class AssemblyReferenceLine
        {
            public AssemblyReferenceLine(Point3D startPoint, Point3D endPoint, Vector3D direction)
            {
                StartPoint = startPoint;
                EndPoint = endPoint;
                Direction = direction;
            }

            public Point3D StartPoint { get; }
            public Point3D EndPoint { get; }
            public Vector3D Direction { get; }
        }

        private static double CalculateDefaultAssemblyReferenceRodDiameterInMeters()
        {
            double standardRadiusInMeters = ConfigManager.Instance.Current.PathEditing.CellSizeMeters;
            standardRadiusInMeters = Math.Max(0.1, Math.Min(0.5, standardRadiusInMeters));
            return standardRadiusInMeters * 0.8;
        }

        private void RenderAssemblyAnchorMarker()
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                return;
            }

            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            Point3D anchorPoint = GetAssemblyTerminalAnchorPoint();
            LogManager.Info(
                $"[直线装配] 已渲染终点锚点标记: ({anchorPoint.X:F2}, {anchorPoint.Y:F2}, {anchorPoint.Z:F2})");
            var markerRoute = new PathRoute("装配对接点")
            {
                Id = AssemblyAnchorMarkerPathId,
                Description = "直线装配终点对接标记"
            };
            AddVisualizationPoint(markerRoute, anchorPoint, "对接点", PathPointType.EndPoint);
            renderPlugin.RenderPointOnly(markerRoute);
        }

        private void RenderAssemblyReferenceLine(AssemblyReferenceLine referenceLine)
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null || referenceLine == null)
            {
                return;
            }

            renderPlugin.RenderRailBaseline(
                AssemblyReferenceLinePathId,
                new List<Point3D> { referenceLine.EndPoint, referenceLine.StartPoint });

            LogManager.Info(
                $"[直线装配] 已渲染参考线: 终点锚点=({referenceLine.EndPoint.X:F2}, {referenceLine.EndPoint.Y:F2}, {referenceLine.EndPoint.Z:F2}), " +
                $"参考线外端=({referenceLine.StartPoint.X:F2}, {referenceLine.StartPoint.Y:F2}, {referenceLine.StartPoint.Z:F2})");
        }

        private void RenderAssemblyCenterGuideLine()
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                return;
            }

            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            HostCoordinateAdapter adapter = CoordinateSystemManager.Instance.CreateHostAdapter();
            ProjectReferenceFrame projectFrame = CreateAssemblyProjectReferenceFrame(adapter);

            Point3D centerPoint = GetAssemblyOpticalAxisReferencePoint();
            Point3D sphereCenterPoint = adapter.FromCanonicalPoint(projectFrame.SphereCenterInCanonical);
            renderPlugin.RenderRailBaseline(
                AssemblyCenterGuideLinePathId,
                new List<Point3D> { sphereCenterPoint, centerPoint },
                RenderStyleName.AssemblyGuideLine);

            LogManager.Info(
                $"[直线装配] 已渲染球心到光轴参考点基准线: 球心=({sphereCenterPoint.X:F2}, {sphereCenterPoint.Y:F2}, {sphereCenterPoint.Z:F2}), " +
                $"光轴参考点=({centerPoint.X:F2}, {centerPoint.Y:F2}, {centerPoint.Z:F2})");
        }

        private void RenderAssemblyEndFaceSeedPoints()
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.RemovePath(AssemblyEndFaceSeedPathId);

            if (_assemblyEndFaceSeedPoints.Count == 0)
            {
                return;
            }

            var markerRoute = new PathRoute("端面三点")
            {
                Id = AssemblyEndFaceSeedPathId,
                Description = "终端安装端面三点"
            };

            for (int i = 0; i < _assemblyEndFaceSeedPoints.Count; i++)
            {
                AddVisualizationPoint(
                    markerRoute,
                    _assemblyEndFaceSeedPoints[i],
                    $"端面点{i + 1}",
                    PathPointType.WayPoint,
                    UnitsConverter.ConvertFromMeters(AssemblyVisualizationPointDiameterInMeters));
            }

            renderPlugin.RenderPointOnly(markerRoute);
        }

        private void RenderAssemblyEndFaceCenter(Point3D centerPoint)
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.RemovePath(AssemblyEndFaceCenterPathId);

            var markerRoute = new PathRoute("端面中心")
            {
                Id = AssemblyEndFaceCenterPathId,
                Description = "终端安装端面中心"
            };
            AddVisualizationPoint(
                markerRoute,
                centerPoint,
                "端面中心",
                PathPointType.WayPoint,
                UnitsConverter.ConvertFromMeters(AssemblyVisualizationPointDiameterInMeters));
            renderPlugin.RenderPointOnly(markerRoute);
        }

        private static void AddVisualizationPoint(
            PathRoute route,
            Point3D position,
            string name,
            PathPointType type,
            double? visualizationDiameter = null)
        {
            if (route == null)
            {
                throw new ArgumentNullException(nameof(route));
            }

            route.Points.Add(new PathPoint(position, name, type)
            {
                Index = route.Points.Count,
                VisualizationDiameter = visualizationDiameter
            });
        }

        private void RenderAssemblyEndFaceNormal(Point3D centerPoint, Vector3 normal)
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.ClearRailBaseline(AssemblyEndFaceNormalPathId);

            double lineLength = UnitsConverter.ConvertFromMeters(Math.Max(0.5, AssemblyReferenceRodDiameterInMeters * 4.0));
            Point3D normalEndPoint = new Point3D(
                centerPoint.X + normal.X * (float)lineLength,
                centerPoint.Y + normal.Y * (float)lineLength,
                centerPoint.Z + normal.Z * (float)lineLength);
            renderPlugin.RenderRailBaseline(
                AssemblyEndFaceNormalPathId,
                new List<Point3D> { centerPoint, normalEndPoint },
                RenderStyleName.AssemblyGuideLine);
        }

        private void BuildAndRenderAssemblyInstallationReference(Point3D firstPickPoint, Point3D secondPickPoint)
        {
            Point3D opticalAxisReferencePoint = GetAssemblyOpticalAxisReferencePoint();
            Point3D sphereCenterPoint = new Point3D(
                AssemblySphereCenterX,
                AssemblySphereCenterY,
                AssemblySphereCenterZ);

            Vector3 opticalAxisDirection = new Vector3(
                (float)(opticalAxisReferencePoint.X - sphereCenterPoint.X),
                (float)(opticalAxisReferencePoint.Y - sphereCenterPoint.Y),
                (float)(opticalAxisReferencePoint.Z - sphereCenterPoint.Z));

            AssemblyInstallationReferenceResult result = AssemblyInstallationReferenceBuilder.Build(
                new Vector3((float)opticalAxisReferencePoint.X, (float)opticalAxisReferencePoint.Y, (float)opticalAxisReferencePoint.Z),
                opticalAxisDirection,
                new Vector3((float)firstPickPoint.X, (float)firstPickPoint.Y, (float)firstPickPoint.Z),
                new Vector3((float)secondPickPoint.X, (float)secondPickPoint.Y, (float)secondPickPoint.Z));

            _hasAssemblyInstallationReference = true;
            _assemblyInstallationPickPoint = AssemblyEndFaceAnalyzer.ToPoint3D((result.PickPoint + result.SecondaryPickPoint) * 0.5f);
            _assemblyInstallationBaseAnchorPoint = AssemblyEndFaceAnalyzer.ToPoint3D(result.AnchorPoint);
            _assemblyInstallationPlaneNormal = result.PlaneNormal;
            _assemblyInstallationPlaneSpanDirection = result.PlaneSpanDirection;
            _assemblyInstallationOffsetDistanceInMeters = UnitsConverter.ConvertToMeters(result.OffsetDistance);
            _assemblyAnchorVerticalOffsetInMeters = DefaultAssemblyAnchorVerticalOffsetInMeters;
            OnPropertyChanged(nameof(AssemblyAnchorVerticalOffsetInMeters));
            UpdateAssemblyInstallationAnchorFromVerticalOffset();

            RenderAssemblyInstallationPickPoints(_assemblyInstallationSeedPoints);
            RenderAssemblyInstallationCenterLine(AssemblyEndFaceAnalyzer.ToPoint3D(result.InstallLineBasePoint), result.OpticalAxisDirection);

            RefreshAssemblyTerminalObjectInfo();
            RefreshAssemblyReferenceRodIfNeeded();
            UpdateMainStatus(
                $"安装参考已计算：安装点=({_assemblyInstallationAnchorPoint.X:F2}, {_assemblyInstallationAnchorPoint.Y:F2}, {_assemblyInstallationAnchorPoint.Z:F2})，偏距={_assemblyInstallationOffsetDistanceInMeters:F3}m，可继续取起点");
            LogManager.Info(
                $"[直线装配] 安装参考已计算: 安装面点1=({firstPickPoint.X:F3}, {firstPickPoint.Y:F3}, {firstPickPoint.Z:F3}), " +
                $"安装面点2=({secondPickPoint.X:F3}, {secondPickPoint.Y:F3}, {secondPickPoint.Z:F3}), " +
                $"安装点=({_assemblyInstallationAnchorPoint.X:F3}, {_assemblyInstallationAnchorPoint.Y:F3}, {_assemblyInstallationAnchorPoint.Z:F3}), " +
                $"偏距={_assemblyInstallationOffsetDistanceInMeters:F3}m, 平面法向=({result.PlaneNormal.X:F4}, {result.PlaneNormal.Y:F4}, {result.PlaneNormal.Z:F4})");
            NotifyRailAssemblyCommandStateChanged();
        }

        private void RenderAssemblyInstallationPickPoints(IReadOnlyList<Point3D> pickPoints)
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.RemovePath(AssemblyInstallationPickPointPathId);
            var markerRoute = new PathRoute("安装点")
            {
                Id = AssemblyInstallationPickPointPathId,
                Description = "终端安装点"
            };
            for (int i = 0; i < pickPoints.Count; i++)
            {
                AddVisualizationPoint(
                    markerRoute,
                    pickPoints[i],
                    $"安装面点{i + 1}",
                    PathPointType.WayPoint,
                    UnitsConverter.ConvertFromMeters(AssemblyVisualizationPointDiameterInMeters));
            }
            renderPlugin.RenderPointOnly(markerRoute);
        }

        private void RenderAssemblyInstallationAnchorPoint(Point3D anchorPoint)
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.RemovePath(AssemblyInstallationAnchorPointPathId);
            var markerRoute = new PathRoute("安装点")
            {
                Id = AssemblyInstallationAnchorPointPathId,
                Description = "终端安装点"
            };
            AddVisualizationPoint(
                markerRoute,
                anchorPoint,
                "安装点",
                PathPointType.WayPoint,
                UnitsConverter.ConvertFromMeters(AssemblyVisualizationPointDiameterInMeters));
            renderPlugin.RenderPointOnly(markerRoute);
        }

        private void RenderAssemblyInstallationCenterLine(Point3D lineBasePoint, Vector3 axisDirection)
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.ClearRailBaseline(AssemblyInstallationCenterLinePathId);
            double halfLength = GetAssemblyInstallationPlaneSideLength() * AssemblyInstallationLineLengthScale / 2.0;
            Point3D startPoint = new Point3D(
                lineBasePoint.X - axisDirection.X * (float)halfLength,
                lineBasePoint.Y - axisDirection.Y * (float)halfLength,
                lineBasePoint.Z - axisDirection.Z * (float)halfLength);
            Point3D endPoint = new Point3D(
                lineBasePoint.X + axisDirection.X * (float)halfLength,
                lineBasePoint.Y + axisDirection.Y * (float)halfLength,
                lineBasePoint.Z + axisDirection.Z * (float)halfLength);
            renderPlugin.RenderRailBaseline(
                AssemblyInstallationCenterLinePathId,
                new List<Point3D> { startPoint, endPoint },
                RenderStyleName.AssemblyGuideLine);
        }

        private void RenderAssemblyInstallationPlane(Point3D planeCenter, Vector3 axisDirection, Vector3 planeSpanDirection)
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            double sideLength = GetAssemblyInstallationPlaneSideLength();
            double halfLength = sideLength / 2.0;
            double thickness = UnitsConverter.ConvertFromMeters(0.01);

            Vector3D xVector = new Vector3D(
                axisDirection.X * (float)sideLength,
                axisDirection.Y * (float)sideLength,
                axisDirection.Z * (float)sideLength);
            Vector3D yVector = new Vector3D(
                planeSpanDirection.X * (float)sideLength,
                planeSpanDirection.Y * (float)sideLength,
                planeSpanDirection.Z * (float)sideLength);
            Point3D origin = new Point3D(
                planeCenter.X - axisDirection.X * (float)halfLength - planeSpanDirection.X * (float)halfLength + _assemblyInstallationPlaneNormal.X * thickness,
                planeCenter.Y - axisDirection.Y * (float)halfLength - planeSpanDirection.Y * (float)halfLength + _assemblyInstallationPlaneNormal.Y * thickness,
                planeCenter.Z - axisDirection.Z * (float)halfLength - planeSpanDirection.Z * (float)halfLength + _assemblyInstallationPlaneNormal.Z * thickness);

            renderPlugin.RemovePath(AssemblyInstallationPlanePathId);
            renderPlugin.RenderRectanglePlane(
                AssemblyInstallationPlanePathId,
                origin,
                xVector,
                yVector,
                RenderStyleName.AssemblyInstallationPlane,
                filled: true);
        }

        private double GetAssemblyInstallationPlaneSideLength()
        {
            if (_assemblyTerminalObject == null || !ModelItemAnalysisHelper.IsModelItemValid(_assemblyTerminalObject))
            {
                return UnitsConverter.ConvertFromMeters(1.0);
            }

            BoundingBox3D bounds = _assemblyTerminalObject.BoundingBox();
            double maxSize = Math.Max(
                bounds.Max.X - bounds.Min.X,
                Math.Max(bounds.Max.Y - bounds.Min.Y, bounds.Max.Z - bounds.Min.Z));
            return maxSize + UnitsConverter.ConvertFromMeters(AssemblyInstallationPlanePaddingInMeters) * 2.0;
        }

        private ProjectReferenceFrame CreateAssemblyProjectReferenceFrame(HostCoordinateAdapter adapter)
        {
            if (adapter == null)
            {
                throw new ArgumentNullException(nameof(adapter));
            }

            Point3D hostSphereCenter = new Point3D(
                AssemblySphereCenterX,
                AssemblySphereCenterY,
                AssemblySphereCenterZ);

            Point3D canonicalSphereCenter = adapter.ToCanonicalPoint(hostSphereCenter);
            return new ProjectReferenceFrame(
                canonicalSphereCenter,
                HostCoordinateAdapter.CanonicalUp,
                ModelAxisConvention.CreateDefaultForHost(adapter.HostType));
        }

        private void ClearAssemblyAnchorMarker()
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.RemovePath(AssemblyAnchorMarkerPathId);
        }

        private void ClearAssemblyReferenceLine()
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.ClearRailBaseline(AssemblyReferenceLinePathId);
        }

        private void ClearAssemblyCenterGuideLine()
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.ClearRailBaseline(AssemblyCenterGuideLinePathId);
        }

        private void ClearAssemblyReferenceLineVisuals()
        {
            AssemblyReferencePathManager.Instance.HideReferenceRod();
            ClearAssemblyAnchorMarker();
            ClearAssemblyCenterGuideLine();
            ClearAssemblyReferenceLine();
            NotifyRailAssemblyCommandStateChanged();
            OnPropertyChanged(nameof(CanRepositionRailStartPoint));
        }

        private void ClearAssemblyEndFaceAnalysisVisuals()
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.RemovePath(AssemblyEndFaceSeedPathId);
            renderPlugin.RemovePath(AssemblyEndFaceCenterPathId);
            renderPlugin.ClearRailBaseline(AssemblyEndFaceNormalPathId);
        }

        private void ResetAssemblyEndFaceAnalysisState()
        {
            _railAssemblyContext.ResetEndFaceAnalysis();
        }

        private void ClearAssemblyInstallationReferenceVisuals()
        {
            var renderPlugin = PathPointRenderPlugin.Instance;
            if (renderPlugin == null)
            {
                return;
            }

            renderPlugin.RemovePath(AssemblyInstallationPickPointPathId);
            renderPlugin.RemovePath(AssemblyInstallationAnchorPointPathId);
            renderPlugin.ClearRailBaseline(AssemblyInstallationCenterLinePathId);
            renderPlugin.ClearRailBaseline(AssemblyInstallationOffsetLinePathId);
            renderPlugin.RemovePath(AssemblyInstallationPlanePathId);
        }

        private void ResetAssemblyInstallationReferenceState()
        {
            _railAssemblyContext.ResetInstallationReference();
            OnPropertyChanged(nameof(AssemblyAnchorVerticalOffsetInMeters));
            NotifyRailAssemblyCommandStateChanged();
        }

        private void CleanupAssemblyReferenceSelection()
        {
            try
            {
                PathClickToolPlugin.MouseClicked -= OnAssemblyReferenceMouseClicked;
                IsSelectingAssemblyStartPoint = false;
                _pathPlanningManager?.EnableMouseHandling();
                _pathPlanningManager?.StopClickTool();
                NotifyRailAssemblyCommandStateChanged();
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 清理起点拾取状态失败: {ex.Message}", ex);
            }
        }

        private void CleanupAssemblyInstallationSelection(bool clearVisuals = true)
        {
            try
            {
                PathClickToolPlugin.MouseClicked -= OnAssemblyInstallationMouseClicked;
                _isSelectingAssemblyInstallationPoint = false;
                _pathPlanningManager?.EnableMouseHandling();
                _pathPlanningManager?.StopClickTool();
                if (clearVisuals)
                {
                    ClearAssemblyInstallationReferenceVisuals();
                }
                NotifyRailAssemblyCommandStateChanged();
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 清理参考安装点拾取状态失败: {ex.Message}", ex);
            }
        }

        private void CleanupAssemblyEndFaceSelection(bool clearVisuals)
        {
            try
            {
                PathClickToolPlugin.MouseClicked -= OnAssemblyEndFaceMouseClicked;
                _isSelectingAssemblyEndFacePoints = false;
                _pathPlanningManager?.EnableMouseHandling();
                _pathPlanningManager?.StopClickTool();
                if (clearVisuals)
                {
                    _assemblyEndFaceSeedPoints.Clear();
                    ClearAssemblyEndFaceAnalysisVisuals();
                    ResetAssemblyEndFaceAnalysisState();
                }
                NotifyRailAssemblyCommandStateChanged();
            }
            catch (Exception ex)
            {
                LogManager.Error($"[直线装配] 清理端面三点拾取状态失败: {ex.Message}", ex);
            }
        }

        private bool IsPickOnAssemblyTerminalObject(PickItemResult pickResult)
        {
            if (pickResult?.ModelItem == null || _assemblyTerminalObject == null)
            {
                return false;
            }

            if (ModelItemAnalysisHelper.ModelItemEquals(pickResult.ModelItem, _assemblyTerminalObject))
            {
                return true;
            }

            return pickResult.ModelItem.AncestorsAndSelf.Any(ancestor => ModelItemAnalysisHelper.ModelItemEquals(ancestor, _assemblyTerminalObject));
        }

        private void AnalyzeCurrentAssemblyEndFace()
        {
            if (_assemblyEndFaceSeedPoints.Count != 3)
            {
                throw new InvalidOperationException("端面分析需要恰好 3 个种子点。");
            }

            var triangles = GeometryHelper.ExtractTriangles(new[] { _assemblyTerminalObject })
                .Select(triangle => new AnalysisTriangle3(
                    new Vector3((float)triangle.Point1.X, (float)triangle.Point1.Y, (float)triangle.Point1.Z),
                    new Vector3((float)triangle.Point2.X, (float)triangle.Point2.Y, (float)triangle.Point2.Z),
                    new Vector3((float)triangle.Point3.X, (float)triangle.Point3.Y, (float)triangle.Point3.Z)))
                .ToList();

            EndFaceAnalysisResult result = AssemblyEndFaceAnalyzer.Analyze(
                triangles,
                new Vector3((float)_assemblyEndFaceSeedPoints[0].X, (float)_assemblyEndFaceSeedPoints[0].Y, (float)_assemblyEndFaceSeedPoints[0].Z),
                new Vector3((float)_assemblyEndFaceSeedPoints[1].X, (float)_assemblyEndFaceSeedPoints[1].Y, (float)_assemblyEndFaceSeedPoints[1].Z),
                new Vector3((float)_assemblyEndFaceSeedPoints[2].X, (float)_assemblyEndFaceSeedPoints[2].Y, (float)_assemblyEndFaceSeedPoints[2].Z));

            if (!result.IsReliable)
            {
                throw new InvalidOperationException(result.DiagnosticMessage);
            }

            Point3D centerPoint = AssemblyEndFaceAnalyzer.ToPoint3D(result.Center);
            Point3D sphereCenterPoint = new Point3D(
                AssemblySphereCenterX,
                AssemblySphereCenterY,
                AssemblySphereCenterZ);
            Vector3 orientedNormal = AssemblyEndFaceAnalyzer.OrientNormalTowardTarget(
                result.Normal,
                new Vector3((float)centerPoint.X, (float)centerPoint.Y, (float)centerPoint.Z),
                new Vector3((float)sphereCenterPoint.X, (float)sphereCenterPoint.Y, (float)sphereCenterPoint.Z));
            _hasAssemblyEndFaceAnalysis = true;
            _assemblyEndFaceCenterPoint = centerPoint;
            _assemblyEndFaceNormal = orientedNormal;
            RenderAssemblyEndFaceSeedPoints();
            RenderAssemblyEndFaceCenter(centerPoint);
            RenderAssemblyEndFaceNormal(centerPoint, orientedNormal);
            RefreshAssemblyTerminalObjectInfo();
            RefreshAssemblyReferenceRodIfNeeded();
            UpdateMainStatus($"端面分析完成：中心=({centerPoint.X:F2}, {centerPoint.Y:F2}, {centerPoint.Z:F2})，候选三角形={result.CandidateTriangleCount}");
            LogManager.Info(
                $"[直线装配] 端面分析完成: 中心=({centerPoint.X:F3}, {centerPoint.Y:F3}, {centerPoint.Z:F3}), " +
                $"法向=({orientedNormal.X:F4}, {orientedNormal.Y:F4}, {orientedNormal.Z:F4}), " +
                $"三角形={result.CandidateTriangleCount}, 顶点={result.CandidateVertexCount}, 偏差={result.MaxPlaneDeviation:F6}");
        }

        private async Task ExecuteNewPathAsync()
        {
            await SafeExecuteAsync(() =>
            {
                UpdateMainStatus("正在创建新路径...");

                // 清除所有现有路径的可视化显示
                if (PathPointRenderPlugin.Instance != null)
                {
                    try
                    {
                        PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                        LogManager.Info("新建路径：已清除现有路径可视化显示（保留网格可视化）");
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"新建路径：清除现有路径可视化失败: {ex.Message}", ex);
                        throw; // 重新抛出异常，让上层处理
                    }
                }

                if (_pathPlanningManager != null)
                {
                    var newRoute = _pathPlanningManager.StartCreatingNewRoute();

                    if (newRoute != null)
                    {
                        // 创建对应的 WPF ViewModel
                        var newPathViewModel = new PathRouteViewModel
                        {
                            Route = newRoute,
                            IsActive = true
                        };

                        // 使用统一的辅助方法创建路径点
                        var pathPoints = CreatePathPointViewModelsFromCoreRoute(newRoute);
                        foreach (var point in pathPoints)
                        {
                            newPathViewModel.Points.Add(point);
                        }

                        // 添加到 UI 列表并选中
                        PathRoutes.Add(newPathViewModel);
                        SelectedPathRoute = newPathViewModel;

                        // 强制重新初始化ToolPlugin以确保获得鼠标焦点，新建路径需要订阅事件
                        if (!ForceReinitializeToolPlugin(subscribeToEvents: true))
                        {
                            UpdateMainStatus("ToolPlugin初始化失败，请重试");
                            LogManager.Error("新建路径：ToolPlugin初始化失败");
                            return;
                        }

                        UpdateMainStatus($"已进入新建路径模式: {newRoute.Name} - 请在3D视图中点击设置路径点");
                        LogManager.Info($"开始新建路径: {newRoute.Name}，已强制重新初始化ToolPlugin获取鼠标焦点");

                        // 不再显示对话框，状态文本已提供足够的反馈
                    }
                    else
                    {
                        UpdateMainStatus("创建新路径失败：没有可通行的物流模型");
                        LogManager.Error("创建新路径失败：没有可通行的物流模型");
                        MessageBox.Show("创建新路径失败：没有找到任何可通行的物流模型。\n请先为模型设置可通行的物流属性，然后再尝试创建路径。", "错误",
                            MessageBoxButton.OK, MessageBoxImage.Warning);
                    }
                }
                else
                {
                    UpdateMainStatus("路径规划管理器未初始化");
                    LogManager.Error("路径规划管理器未初始化");
                }
            }, "新建路径");
        }

        private async Task ExecuteNewRailPathAsync()
        {
            await SafeExecuteAsync(() =>
            {
                UpdateMainStatus("正在创建传统空轨路径...");

                // 检查是否有空轨基准路径
                if (PathPointRenderPlugin.Instance != null)
                {
                    try
                    {
                        // 清除所有现有路径的可视化显示
                        PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                        LogManager.Info("新建传统空轨路径：已清除现有路径可视化显示（保留网格可视化）");
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"新建传统空轨路径：清除现有路径可视化失败: {ex.Message}", ex);
                        throw;
                    }
                }

                // 自动提取并显示所有空轨模型的基准线
                ExtractAndRenderRailBaselinePaths();

                if (_pathPlanningManager != null)
                {
                        // 创建传统空轨路径
                    var newRoute = _pathPlanningManager.StartCreatingNewRoute(
                        isRailPath: true, 
                        pathType: PathType.Rail);

                    if (newRoute != null)
                    {
                        // 创建对应的 WPF ViewModel
                        var newPathViewModel = new PathRouteViewModel
                        {
                            Route = newRoute,
                            IsActive = true,
                            PathType = PathType.Rail
                        };

                        // 使用统一的辅助方法创建路径点
                        var pathPoints = CreatePathPointViewModelsFromCoreRoute(newRoute);
                        foreach (var point in pathPoints)
                        {
                            newPathViewModel.Points.Add(point);
                        }

                        // 添加到 UI 列表并选中
                        PathRoutes.Add(newPathViewModel);
                        SelectedPathRoute = newPathViewModel;

                        // 强制重新初始化ToolPlugin以确保获得鼠标焦点
                        if (!ForceReinitializeToolPlugin(subscribeToEvents: true))
                        {
                            UpdateMainStatus("ToolPlugin初始化失败，请重试");
                            LogManager.Error("新建传统空轨路径：ToolPlugin初始化失败");
                            return;
                        }

                        // 启动点击工具，设置空轨吸附模式
                        _pathPlanningManager.StartClickTool(PathPointType.WayPoint, enableRailSnapping: true);
                        LogManager.Info($"已启动传统空轨路径点击工具（吸附模式）: {newRoute.Name}");

                        UpdateMainStatus($"已进入传统空轨路径模式: {newRoute.Name} - 请在3D视图中点击空轨模型设置路径点（将自动吸附到基准路径）");
                        LogManager.Info($"开始新建传统空轨路径: {newRoute.Name}，已强制重新初始化ToolPlugin获取鼠标焦点");
                    }
                    else
                    {
                        UpdateMainStatus("创建传统空轨路径失败：没有可通行的物流模型");
                        LogManager.Error("创建传统空轨路径失败：没有可通行的物流模型");
                        MessageBox.Show("创建传统空轨路径失败：没有找到任何可通行的物流模型。\n请先为模型设置可通行的物流属性，然后再尝试创建路径。", "错误",
                            MessageBoxButton.OK, MessageBoxImage.Warning);
                    }
                }
                else
                {
                    UpdateMainStatus("路径规划管理器未初始化");
                    LogManager.Error("路径规划管理器未初始化");
                }
                        }, "新建传统空轨路径");
                        }
                
                        /// <summary>
                                /// 执行新建吊装路径命令
                                /// </summary>
                                private async Task ExecuteNewHoistingPathAsync()
                                {
                                    await SafeExecuteAsync(() =>
                                    {
                                        UpdateMainStatus("正在创建新吊装路径...");
                        
                                        // 清除所有现有路径的可视化显示
                                        if (PathPointRenderPlugin.Instance != null)
                                        {
                                            try
                                            {
                                                PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                                                LogManager.Info("新建吊装路径：已清除现有路径可视化显示（保留网格可视化）");
                                            }
                                            catch (Exception ex)
                                            {
                                                LogManager.Error($"新建吊装路径：清除现有路径可视化失败: {ex.Message}", ex);
                                                throw;
                                            }
                                        }
                        
                                        if (_pathPlanningManager != null)
                                        {
                                            // 创建吊装路径
                                            var newRoute = _pathPlanningManager.StartCreatingNewRoute(
                                                isRailPath: false, 
                                                pathType: PathType.Hoisting);
                        
                                            if (newRoute != null)
                                            {
                                                // 创建对应的 WPF ViewModel
                                                var newPathViewModel = new PathRouteViewModel
                                                {
                                                    Route = newRoute,
                                                    IsActive = true,
                                                    PathType = PathType.Hoisting
                                                };

                                                // 使用统一的辅助方法创建路径点
                                                var pathPoints = CreatePathPointViewModelsFromCoreRoute(newRoute);
                                                foreach (var point in pathPoints)
                                                {
                                                    newPathViewModel.Points.Add(point);
                                                }
                        
                                                // 添加到 UI 列表并选中
                                                PathRoutes.Add(newPathViewModel);
                                                SelectedPathRoute = newPathViewModel;
                        
                                                // 强制重新初始化ToolPlugin以确保获得鼠标焦点
                                                if (!ForceReinitializeToolPlugin(subscribeToEvents: true))
                                                {
                                                    UpdateMainStatus("ToolPlugin初始化失败，请重试");
                                                    LogManager.Error("新建吊装路径：ToolPlugin初始化失败");
                                                    return;
                                                }
                        
                                                // 启动点击工具，启用吊装模式
                                                _pathPlanningManager.StartClickTool(PathPointType.WayPoint, enableRailSnapping: false, enableHoistingMode: true);
                                                LogManager.Info($"已启动吊装路径点击工具: {newRoute.Name}");
                        
                                                UpdateMainStatus($"已进入新建吊装路径模式: {newRoute.Name} - 请在3D视图中点击吊装起点（地面位置）");
                                                LogManager.Info($"开始新建吊装路径: {newRoute.Name}，已强制重新初始化ToolPlugin获取鼠标焦点");
                                            }
                                            else
                                            {
                                                UpdateMainStatus("创建新吊装路径失败：没有可通行的物流模型");
                                                LogManager.Error("创建新吊装路径失败：没有可通行的物流模型");
                                                MessageBox.Show("创建新吊装路径失败：没有找到任何可通行的物流模型。\n请先为模型设置可通行的物流属性，然后再尝试创建路径。", "错误",
                                                    MessageBoxButton.OK, MessageBoxImage.Warning);
                                            }
                                        }
                                        else
                                        {
                                            UpdateMainStatus("路径规划管理器未初始化");
                                            LogManager.Error("路径规划管理器未初始化");
                                        }
                                    }, "新建吊装路径");
                                }

                                #region 多层吊装页签模式实现

                                /// <summary>
                                /// 执行新建多层阶梯式吊装路径命令 - 启用页签模式
                                /// </summary>
                                private async Task ExecuteNewMultiLevelHoistingPathAsync()
                                {
                                    await SafeExecuteAsync(() =>
                                    {
                                        UpdateMainStatus("正在创建多层阶梯式吊装路径...");

                                        // 清除所有现有路径的可视化显示
                                        if (PathPointRenderPlugin.Instance != null)
                                        {
                                            try
                                            {
                                                PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                                                LogManager.Info("新建多层吊装路径：已清除现有路径可视化显示（保留网格可视化）");
                                            }
                                            catch (Exception ex)
                                            {
                                                LogManager.Error($"新建多层吊装路径：清除现有路径可视化失败: {ex.Message}", ex);
                                                throw;
                                            }
                                        }

                                        if (_pathPlanningManager == null)
                                        {
                                            UpdateMainStatus("路径规划管理器未初始化");
                                            LogManager.Error("路径规划管理器未初始化");
                                            return;
                                        }

                                        // 启用多层吊装页签模式
                                        IsMultiLevelHoistingMode = true;
                                        
                                        // 清空集合和重置状态
                                        MultiLevelItems.Clear();
                                        _multiLevelStartPoint = null;
                                        _multiLevelEndPoint = null;
                                        _hasMultiLevelStartPoint = false;
                                        _hasMultiLevelEndPoint = false;
                                        MultiLevelStartPointText = "未选择";
                                        MultiLevelEndPointText = "未选择";
                                        UpdateMultiLevelStats();
                                        
                                        // 重置选择状态
                                        _isSelectingMultiLevelStartPoint = false;
                                        _isSelectingMultiLevelEndPoint = false;
                                        _currentSelectingLevelTarget = null;
                                        
                                        // 清理之前的点击事件订阅
                                        PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                        
                                        UpdateMainStatus("多层吊装模式已启用 - 请设置起点、终点并添加层级");
                                        LogManager.Info("[多层吊装] 页签模式已启用");

                                    }, "新建多层吊装路径");
                                }

                                /// <summary>
                                /// 执行选择多层吊装起点命令
                                /// </summary>
                                private async Task ExecuteSelectMultiLevelStartPointAsync()
                                {
                                    await SafeExecuteAsync(() =>
                                    {
                                        if (_pathPlanningManager == null) return;

                                        // 清除之前的起点标记
                                        if (_hasMultiLevelStartPoint && PathPointRenderPlugin.Instance != null)
                                        {
                                            var existingRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == "MultiLevelStartPoint");
                                            if (existingRoute != null)
                                            {
                                                PathPointRenderPlugin.Instance.RemovePath(existingRoute.Route.Id);
                                            }
                                        }

                                        // 使用自动路径规划相同的模式
                                        _pathPlanningManager.DisableMouseHandling();
                                        
                                        // 设置状态
                                        _isSelectingMultiLevelStartPoint = true;
                                        _isSelectingMultiLevelEndPoint = false;
                                        _currentSelectingLevelTarget = null;
                                        
                                        // 订阅点击事件
                                        PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                        PathClickToolPlugin.MouseClicked += OnMultiLevelHoistingMouseClicked;
                                        
                                        // 强制重新初始化ToolPlugin以获取鼠标焦点
                                        ForceReinitializeToolPlugin(subscribeToEvents: false);
                                        
                                        UpdateMainStatus("请在3D视图中点击选择起点（地面起吊位置）...");
                                        LogManager.Info("[多层吊装] 开始选择起点");
                                    }, "选择多层吊装起点");
                                }

                                /// <summary>
                                /// 执行选择多层吊装终点命令
                                /// </summary>
                                private async Task ExecuteSelectMultiLevelEndPointAsync()
                                {
                                    await SafeExecuteAsync(() =>
                                    {
                                        if (_pathPlanningManager == null) return;

                                        // 清除之前的终点标记
                                        if (_hasMultiLevelEndPoint && PathPointRenderPlugin.Instance != null)
                                        {
                                            var existingRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == "MultiLevelEndPoint");
                                            if (existingRoute != null)
                                            {
                                                PathPointRenderPlugin.Instance.RemovePath(existingRoute.Route.Id);
                                            }
                                        }

                                        // 使用自动路径规划相同的模式
                                        _pathPlanningManager.DisableMouseHandling();
                                        
                                        // 设置状态
                                        _isSelectingMultiLevelStartPoint = false;
                                        _isSelectingMultiLevelEndPoint = true;
                                        _currentSelectingLevelTarget = null;
                                        
                                        // 订阅点击事件
                                        PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                        PathClickToolPlugin.MouseClicked += OnMultiLevelHoistingMouseClicked;
                                        
                                        // 强制重新初始化ToolPlugin以获取鼠标焦点
                                        ForceReinitializeToolPlugin(subscribeToEvents: false);
                                        
                                        UpdateMainStatus("请在3D视图中点击选择终点（地面落地位置）...");
                                        LogManager.Info("[多层吊装] 开始选择终点");
                                    }, "选择多层吊装终点");
                                }

                                /// <summary>
                                /// 执行添加层级命令
                                /// </summary>
                                private void ExecuteAddMultiLevel()
                                {
                                    var level = new HoistingLevelItem
                                    {
                                        Index = MultiLevelItems.Count,
                                        HeightInMeters = 3.0,
                                        Description = $"层级{MultiLevelItems.Count + 1}"
                                    };
                                    MultiLevelItems.Add(level);
                                    UpdateMultiLevelStats();
                                    
                                    LogManager.Info($"[多层吊装] 添加层级{level.Index + 1}, 高度={level.HeightInMeters}m");
                                    UpdateMainStatus($"已添加层级{level.Index + 1}，请设置目标位置");
                                }

                                /// <summary>
                                /// 执行删除层级命令
                                /// </summary>
                                private void ExecuteDeleteMultiLevel(HoistingLevelItem item)
                                {
                                    if (item == null) return;
                                    
                                    // 清除该层级的可视化标记
                                    if (PathPointRenderPlugin.Instance != null)
                                    {
                                        var existingRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == $"MultiLevelLevel{item.Index}");
                                        if (existingRoute != null)
                                        {
                                            PathPointRenderPlugin.Instance.RemovePath(existingRoute.Route.Id);
                                        }
                                    }
                                    
                                    MultiLevelItems.Remove(item);
                                    
                                    // 重新编号
                                    for (int i = 0; i < MultiLevelItems.Count; i++)
                                    {
                                        MultiLevelItems[i].Index = i;
                                    }
                                    
                                    UpdateMultiLevelStats();
                                    LogManager.Info($"[多层吊装] 删除层级，剩余{MultiLevelItems.Count}个层级");
                                }

                                /// <summary>
                                /// 执行拾取层级目标位置命令
                                /// </summary>
                                private void ExecutePickMultiLevelTarget(HoistingLevelItem item)
                                {
                                    if (item == null || _pathPlanningManager == null) return;
                                    
                                    // 清除之前的标记
                                    if (PathPointRenderPlugin.Instance != null)
                                    {
                                        var existingRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == $"MultiLevelLevel{item.Index}");
                                        if (existingRoute != null)
                                        {
                                            PathPointRenderPlugin.Instance.RemovePath(existingRoute.Route.Id);
                                        }
                                    }
                                    
                                    // 使用自动路径规划相同的模式
                                    _pathPlanningManager.DisableMouseHandling();
                                    
                                    // 设置状态
                                    _isSelectingMultiLevelStartPoint = false;
                                    _isSelectingMultiLevelEndPoint = false;
                                    _currentSelectingLevelTarget = item;
                                    
                                    // 订阅点击事件
                                    PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                    PathClickToolPlugin.MouseClicked += OnMultiLevelHoistingMouseClicked;
                                    
                                    // 强制重新初始化ToolPlugin以获取鼠标焦点
                                    ForceReinitializeToolPlugin(subscribeToEvents: false);
                                    
                                    UpdateMainStatus($"请在3D视图中点击层级{item.Index + 1}的目标位置...");
                                    LogManager.Info($"[多层吊装] 开始选择层级{item.Index + 1}的目标位置");
                                }

                                /// <summary>
                                /// 执行创建多层吊装路径命令
                                /// </summary>
                                private async Task ExecuteCreateMultiLevelPathAsync()
                                {
                                    await SafeExecuteAsync(() =>
                                    {
                                        // 验证输入
                                        if (!_hasMultiLevelStartPoint)
                                        {
                                            MessageBox.Show("请先选择起点", "验证失败", MessageBoxButton.OK, MessageBoxImage.Warning);
                                            return;
                                        }

                                        if (!_hasMultiLevelEndPoint)
                                        {
                                            MessageBox.Show("请先选择终点", "验证失败", MessageBoxButton.OK, MessageBoxImage.Warning);
                                            return;
                                        }

                                        if (MultiLevelItems.Count == 0)
                                        {
                                            MessageBox.Show("请至少添加一个层级", "验证失败", MessageBoxButton.OK, MessageBoxImage.Warning);
                                            return;
                                        }

                                        // 验证所有层级
                                        foreach (var level in MultiLevelItems)
                                        {
                                            if (level.HeightInMeters <= 0)
                                            {
                                                MessageBox.Show($"层级{level.Index + 1}的高度必须大于0", "验证失败",
                                                    MessageBoxButton.OK, MessageBoxImage.Warning);
                                                return;
                                            }
                                            
                                            if (level.HorizontalTarget == null)
                                            {
                                                MessageBox.Show($"请为层级{level.Index + 1}设置目标位置", "验证失败",
                                                    MessageBoxButton.OK, MessageBoxImage.Warning);
                                                return;
                                            }
                                        }

                                        // 创建层级列表
                                        var levels = new List<HoistingLevel>();
                                        foreach (var item in MultiLevelItems)
                                        {
                                            levels.Add(new HoistingLevel
                                            {
                                                Index = item.Index,
                                                HeightInMeters = item.HeightInMeters,
                                                HorizontalTarget = item.HorizontalTarget,
                                                IsRise = true,
                                                Description = item.Description
                                            });
                                        }

                                        LogManager.Info($"[多层吊装] 创建路径：起点({_multiLevelStartPoint.X:F2},{_multiLevelStartPoint.Y:F2},{_multiLevelStartPoint.Z:F2}), " +
                                                       $"终点({_multiLevelEndPoint.X:F2},{_multiLevelEndPoint.Y:F2},{_multiLevelEndPoint.Z:F2}), 层级数={levels.Count}");

                                        // 使用命令创建路径
                                        var parameters = new AerialPathParameters
                                        {
                                            PathType = PathType.Hoisting,
                                            HoistingMode = HoistingMode.MultiLevel,
                                            StartPoint = _multiLevelStartPoint,
                                            EndPoint = _multiLevelEndPoint,
                                            HoistingLevels = levels
                                        };

                                        var command = new CreateAerialPathCommand(parameters);
                                        var result = command.ExecuteAsync().Result;

                                        if (result.IsSuccess && result is PathPlanningResult<PathRoute> typedResult)
                                        {
                                            var route = typedResult.Data;
                                            LogManager.Info($"[多层吊装] 路径创建成功: {route.Name}, 点数: {route.Points.Count}");

                                            // 创建 ViewModel
                                            var newPathViewModel = new PathRouteViewModel
                                            {
                                                Route = route,
                                                IsActive = true,
                                                PathType = PathType.Hoisting
                                            };

                                            var pathPoints = CreatePathPointViewModelsFromCoreRoute(route);
                                            foreach (var point in pathPoints)
                                            {
                                                newPathViewModel.Points.Add(point);
                                            }

                                            PathRoutes.Add(newPathViewModel);
                                            SelectedPathRoute = newPathViewModel;

                                            UpdateMainStatus($"✓ 多层吊装路径创建成功: {route.Name} - {levels.Count}个层级, {route.Points.Count}个路径点");
                                            OnPropertyChanged(nameof(PathRoutes));
                                            
                                            // 退出多层吊装模式
                                            ExecuteCancelMultiLevelHoisting();
                                        }
                                        else
                                        {
                                            UpdateMainStatus($"创建失败: {result.Message}");
                                            MessageBox.Show($"创建多层吊装路径失败: {result.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                                        }
                                    }, "创建多层吊装路径");
                                }

                                /// <summary>
                                /// 执行取消多层吊装命令
                                /// </summary>
                                private void ExecuteCancelMultiLevelHoisting()
                                {
                                    // 清理事件订阅
                                    PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                    
                                    // 清理可视化标记
                                    if (PathPointRenderPlugin.Instance != null)
                                    {
                                        // 清理起点标记
                                        var startRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == "MultiLevelStartPoint");
                                        if (startRoute != null)
                                        {
                                            PathPointRenderPlugin.Instance.RemovePath(startRoute.Route.Id);
                                        }
                                        
                                        // 清理终点标记
                                        var endRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == "MultiLevelEndPoint");
                                        if (endRoute != null)
                                        {
                                            PathPointRenderPlugin.Instance.RemovePath(endRoute.Route.Id);
                                        }
                                        
                                        // 清理层级标记
                                        for (int i = 0; i < MultiLevelItems.Count; i++)
                                        {
                                            var levelRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == $"MultiLevelLevel{i}");
                                            if (levelRoute != null)
                                            {
                                                PathPointRenderPlugin.Instance.RemovePath(levelRoute.Route.Id);
                                            }
                                        }
                                    }
                                    
                                    // 重置状态
                                    IsMultiLevelHoistingMode = false;
                                    MultiLevelItems.Clear();
                                    _multiLevelStartPoint = null;
                                    _multiLevelEndPoint = null;
                                    _hasMultiLevelStartPoint = false;
                                    _hasMultiLevelEndPoint = false;
                                    MultiLevelStartPointText = "未选择";
                                    MultiLevelEndPointText = "未选择";
                                    _isSelectingMultiLevelStartPoint = false;
                                    _isSelectingMultiLevelEndPoint = false;
                                    _currentSelectingLevelTarget = null;
                                    
                                    // 恢复PathPlanningManager鼠标处理
                                    _pathPlanningManager?.EnableMouseHandling();
                                    _pathPlanningManager?.StopClickTool();
                                    
                                    UpdateMultiLevelStats();
                                    UpdateMainStatus("多层吊装模式已取消");
                                    LogManager.Info("[多层吊装] 页签模式已取消");
                                }

                                /// <summary>
                                /// 更新多层吊装统计信息
                                /// </summary>
                                private void UpdateMultiLevelStats()
                                {
                                    int levelCount = MultiLevelItems.Count;
                                    int pointCount = levelCount > 0 ? 2 + levelCount * 2 + 2 : 0;
                                    MultiLevelStatsText = $"层级数: {levelCount} | 预估路径点数: {pointCount}";
                                    
                                    // 通知CanCreateMultiLevelPath变更
                                    OnPropertyChanged(nameof(CanCreateMultiLevelPath));
                                    
                                    // 通知命令可执行状态变更
                                    System.Windows.Input.CommandManager.InvalidateRequerySuggested();
                                }

                                /// <summary>
                                /// 多层吊装路径鼠标点击处理
                                /// </summary>
                                private void OnMultiLevelHoistingMouseClicked(object sender, PickItemResult e)
                                {
                                    if (e?.Point == null) return;

                                    var point = e.Point;
                                    
                                    if (_isSelectingMultiLevelStartPoint)
                                    {
                                        // 设置起点
                                        _multiLevelStartPoint = point;
                                        _hasMultiLevelStartPoint = true;
                                        MultiLevelStartPointText = $"({point.X:F2}, {point.Y:F2}, {point.Z:F2})";
                                        
                                        // 渲染起点标记
                                        RenderMultiLevelPointMarker(point, isStart: true);
                                        
                                        LogManager.Info($"[多层吊装] 起点已设置: ({point.X:F2}, {point.Y:F2}, {point.Z:F2})");
                                        UpdateMainStatus($"起点已设置，请选择终点或添加层级");
                                        
                                        // 清理事件订阅并停用ToolPlugin
                                        PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                        _pathPlanningManager?.EnableMouseHandling();
                                        _pathPlanningManager?.StopClickTool();
                                        _isSelectingMultiLevelStartPoint = false;
                                        
                                        // 更新统计
                                        UpdateMultiLevelStats();
                                    }
                                    else if (_isSelectingMultiLevelEndPoint)
                                    {
                                        // 设置终点
                                        _multiLevelEndPoint = point;
                                        _hasMultiLevelEndPoint = true;
                                        MultiLevelEndPointText = $"({point.X:F2}, {point.Y:F2}, {point.Z:F2})";
                                        
                                        // 渲染终点标记
                                        RenderMultiLevelPointMarker(point, isStart: false);
                                        
                                        LogManager.Info($"[多层吊装] 终点已设置: ({point.X:F2}, {point.Y:F2}, {point.Z:F2})");
                                        UpdateMainStatus($"终点已设置，可以添加层级创建路径");
                                        
                                        // 清理事件订阅并停用ToolPlugin
                                        PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                        _pathPlanningManager?.EnableMouseHandling();
                                        _pathPlanningManager?.StopClickTool();
                                        _isSelectingMultiLevelEndPoint = false;
                                        
                                        // 更新统计
                                        UpdateMultiLevelStats();
                                    }
                                    else if (_currentSelectingLevelTarget != null)
                                    {
                                        // 设置层级目标位置
                                        var targetPoint = new Point3D(point.X, point.Y, point.Z);
                                        _currentSelectingLevelTarget.HorizontalTarget = targetPoint;
                                        
                                        // 渲染层级目标标记
                                        RenderMultiLevelLevelMarker(targetPoint, _currentSelectingLevelTarget.Index);
                                        
                                        LogManager.Info($"[多层吊装] 层级{_currentSelectingLevelTarget.Index + 1}目标位置已设置: ({point.X:F2}, {point.Y:F2})");
                                        UpdateMainStatus($"层级{_currentSelectingLevelTarget.Index + 1}目标位置已设置，可以继续添加层级或点击创建路径");
                                        
                                        // 清理事件订阅并停用ToolPlugin
                                        PathClickToolPlugin.MouseClicked -= OnMultiLevelHoistingMouseClicked;
                                        _pathPlanningManager?.EnableMouseHandling();
                                        _pathPlanningManager?.StopClickTool();
                                        _currentSelectingLevelTarget = null;
                                    }
                                }

                                /// <summary>
                                /// 渲染层级目标位置标记
                                /// </summary>
                                private void RenderMultiLevelLevelMarker(Point3D point, int levelIndex)
                                {
                                    if (PathPointRenderPlugin.Instance == null) return;

                                    var routeName = $"MultiLevelLevel{levelIndex}";
                                    
                                    // 移除之前的标记
                                    var existingRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == routeName);
                                    if (existingRoute != null)
                                    {
                                        PathPointRenderPlugin.Instance.RemovePath(existingRoute.Route.Id);
                                    }

                                    // 创建临时路径
                                    var route = new PathRoute(routeName)
                                    {
                                        Description = $"层级{levelIndex + 1}目标位置"
                                    };
                                    var pathPoint = new PathPoint
                                    {
                                        Name = $"层级{levelIndex + 1}",
                                        Position = point,
                                        Type = PathPointType.WayPoint
                                    };
                                    route.AddPoint(pathPoint);

                                    // 渲染点（使用不同颜色区分层级）
                                    PathPointRenderPlugin.Instance.RenderPointOnly(route);
                                    LogManager.Info($"[多层吊装] 层级{levelIndex + 1}目标标记已渲染");
                                }

                                /// <summary>
                                /// 渲染多层吊装路径的点标记
                                /// </summary>
                                private void RenderMultiLevelPointMarker(Point3D point, bool isStart)
                                {
                                    if (PathPointRenderPlugin.Instance == null) return;

                                    var routeName = isStart ? "MultiLevelStartPoint" : "MultiLevelEndPoint";
                                    var displayName = isStart ? "多层吊装起点" : "多层吊装终点";
                                    var pointType = isStart ? PathPointType.StartPoint : PathPointType.EndPoint;
                                    
                                    // 移除之前的标记
                                    var existingRoute = PathRoutes.FirstOrDefault(r => r.Route.Name == routeName);
                                    if (existingRoute != null)
                                    {
                                        PathPointRenderPlugin.Instance.RemovePath(existingRoute.Route.Id);
                                    }

                                    // 创建临时路径
                                    var route = new PathRoute(routeName)
                                    {
                                        Description = displayName
                                    };
                                    var pathPoint = new PathPoint
                                    {
                                        Name = displayName,
                                        Position = point,
                                        Type = pointType
                                    };
                                    route.AddPoint(pathPoint);

                                    // 渲染点
                                    PathPointRenderPlugin.Instance.RenderPointOnly(route);
                                }

                                #endregion

        /// <summary>
        /// 提取并渲染所有空轨模型的基准路径
        /// </summary>
        private void ExtractAndRenderRailBaselinePaths()
        {
            try
            {
                LogManager.Info("[空轨路径] 开始提取所有空轨模型的基准路径");
                int successCount = PathPlanning.RailGeometryHelper.ExtractAndRenderAllRailBaselines();
                LogManager.Info($"[空轨路径] 空轨基准路径提取完成，成功 {successCount} 个");
            }
            catch (Exception ex)
            {
                LogManager.Error($"[空轨路径] 提取空轨基准路径失败: {ex.Message}");
            }
        }

        private async Task ExecuteDeletePathAsync()
        {
            if (SelectedPathRoute == null) return;

            await SafeExecuteAsync(() =>
            {
                var pathName = SelectedPathRoute.Name;
                UpdateMainStatus($"正在删除路径: {pathName}...");

                // 清理当前路径的3D可视化显示（使用新的统一API）
                if (PathPointRenderPlugin.Instance != null)
                {
                    try
                    {
                        // 使用路径名找到对应的Core路径，获取其ID进行精确清理
                        string pathIdToRemove = null;
                        if (_pathPlanningManager != null)
                        {
                            var coreRoute = _pathPlanningManager.Routes.FirstOrDefault(r => r.Name == pathName);
                            if (coreRoute != null)
                            {
                                pathIdToRemove = coreRoute.Id;
                                LogManager.Info($"删除路径：找到Core路径ID: {pathIdToRemove}");

                                // 使用新的API精确删除该路径
                                PathPointRenderPlugin.Instance.RemovePath(pathIdToRemove);
                                LogManager.Info($"删除路径：已清除路径 {pathName} (ID: {pathIdToRemove}) 的可视化显示");
                            }
                            else
                            {
                                LogManager.Warning($"删除路径：未找到路径 {pathName} 对应的Core路径，无法清理可视化");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"删除路径：清除路径可视化失败: {ex.Message}", ex);
                        throw; // 重新抛出异常，让上层处理
                    }
                }

                // 通知PathPlanningManager删除对应的路径（包括数据库删除）
                if (_pathPlanningManager != null)
                {
                    var coreRoute = _pathPlanningManager.Routes.FirstOrDefault(r => r.Name == pathName);
                    if (coreRoute != null)
                    {
                        // 使用PathPlanningManager的DeleteRoute方法，确保数据库也被删除
                        bool deleteSuccess = _pathPlanningManager.DeleteRoute(coreRoute);
                        if (deleteSuccess)
                        {
                            LogManager.Info($"删除路径：已从PathPlanningManager和数据库删除路径: {pathName}");
                        }
                        else
                        {
                            LogManager.Warning($"删除路径：PathPlanningManager删除失败: {pathName}");
                        }
                    }
                }

                // 更新UI
                PathRoutes.Remove(SelectedPathRoute);
                SelectedPathRoute = null;
                UpdateMainStatus($"已完全删除路径: {pathName}");
            }, "删除路径");
        }

        private async Task ExecuteDuplicatePathAsync()
        {
            if (SelectedPathRoute == null || _pathPlanningManager == null) return;

            await SafeExecuteAsync(async () =>
            {
                var sourceRoute = SelectedPathRoute.Route ??
                                  _pathPlanningManager.Routes.FirstOrDefault(r => r.Id == SelectedPathRoute.Id);
                if (sourceRoute == null)
                {
                    throw new InvalidOperationException("未找到要复制的路径数据");
                }

                UpdateMainStatus($"正在复制路径: {sourceRoute.Name}...");

                var duplicatedRoute = sourceRoute.Clone();
                duplicatedRoute.Name = PathHelper.BuildDuplicatedPathName(sourceRoute.Name);
                duplicatedRoute.CreatedTime = DateTime.Now;
                duplicatedRoute.LastModified = DateTime.Now;

                if (!_pathPlanningManager.AddRoute(duplicatedRoute))
                {
                    throw new InvalidOperationException($"复制路径失败: {sourceRoute.Name}");
                }

                var duplicatedPathViewModel = new PathRouteViewModel(isFromDatabase: true)
                {
                    Route = duplicatedRoute,
                    IsActive = false
                };
                duplicatedPathViewModel.SetTimeInfo(duplicatedRoute.CreatedTime, duplicatedRoute.LastModified);

                foreach (var point in CreatePathPointViewModelsFromCoreRoute(duplicatedRoute))
                {
                    duplicatedPathViewModel.Points.Add(point);
                }

                PathRoutes.Add(duplicatedPathViewModel);
                SelectedPathRoute = duplicatedPathViewModel;
                UpdateMainStatus($"已复制路径: {sourceRoute.Name} -> {duplicatedPathViewModel.Name}");

                await Task.CompletedTask;
            }, "复制路径");
        }

        #endregion

        #region 坐标编辑命令

        private void ExecuteEditPointCoordinates(PathPointViewModel point)
        {
            if (point == null) return;

            try
            {
                // 创建并显示对话框
                // 注意：在Navisworks插件的ViewModel中，不设置Owner
                // 因为Application.Current.MainWindow在Navisworks环境中不可用
                var dialog = new EditCoordinatesWindow(point.X, point.Y, point.Z, point.Name, point.Type.ToString());

                if (dialog.ShowDialog() == true)
                {
                    // 同步更新到底层数据模型
                    if (_pathPlanningManager != null)
                    {
                        var coreRoute = _pathPlanningManager.Routes.FirstOrDefault(r => r.Id == SelectedPathRoute.Id);
                        if (coreRoute != null)
                        {
                            // 🔥 通过Id查找路径点索引（而不是使用可能过时的point.Index）
                            int pointIndex = -1;
                            for (int i = 0; i < coreRoute.Points.Count; i++)
                            {
                                if (coreRoute.Points[i].Id == point.Id)
                                {
                                    pointIndex = i;
                                    break;
                                }
                            }

                            // 验证索引是否有效
                            if (pointIndex < 0 || pointIndex >= coreRoute.Points.Count)
                            {
                                LogManager.Error($"[坐标编辑] 索引错误: 通过Id查找失败，point.Id={point.Id}, coreRoute.Points.Count={coreRoute.Points.Count}");
                                System.Windows.MessageBox.Show($"路径点索引错误：无法找到对应的路径点，请刷新路径列表后重试", "错误", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
                                return;
                            }

                            LogManager.Info($"[坐标编辑] 修改点: {point.Name}, 类型: {point.Type}, 索引: {pointIndex}");

                            var corePoint = coreRoute.Points[pointIndex];
                            LogManager.Info($"[坐标编辑] Core路径点: {corePoint.Name}, 索引: {pointIndex}, 位置: ({corePoint.Position.X:F3}, {corePoint.Position.Y:F3}, {corePoint.Position.Z:F3})");

                            // 使用公共方法更新路径点（自动处理吊装路径约束）
                            var newPosition = new Point3D(dialog.X, dialog.Y, dialog.Z);
                            bool success = _pathPlanningManager.UpdatePathPointWithConstraints(coreRoute, pointIndex, newPosition);

                            if (success)
                            {
                                // 更新ViewModel中的坐标（从Core数据同步）
                                corePoint = coreRoute.Points[pointIndex];
                                point.X = corePoint.Position.X;
                                point.Y = corePoint.Position.Y;
                                point.Z = corePoint.Position.Z;

                                // 刷新视图
                                UpdatePathVisualization();

                                LogManager.Info($"已更新路径点 {point.Name} 的坐标为 ({point.X:F3}, {point.Y:F3}, {point.Z:F3})");
                            }
                            else
                            {
                                LogManager.Error($"更新路径点失败: {point.Name}");
                                System.Windows.MessageBox.Show($"更新路径点失败", "错误", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"编辑坐标对话框操作失败: {ex.Message}", ex);
                System.Windows.MessageBox.Show($"无法打开编辑对话框: {ex.Message}", "错误", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
            }
        }

        /// <summary>
        /// 从Core路径创建PathPointViewModel列表（统一处理吊装路径属性）
        /// </summary>
        private List<PathPointViewModel> CreatePathPointViewModelsFromCoreRoute(PathRoute coreRoute)
        {
            var points = new List<PathPointViewModel>();

            for (int i = 0; i < coreRoute.Points.Count; i++)
            {
                var corePoint = coreRoute.Points[i];
                var wpfPoint = new PathPointViewModel
                {
                    Id = corePoint.Id,
                    Name = corePoint.Name,
                    X = corePoint.X,
                    Y = corePoint.Y,
                    Z = corePoint.Z,
                    Type = corePoint.Type,
                    Index = i  // 🔥 设置正确的索引
                };
                points.Add(wpfPoint);
            }

            return points;
        }

        private bool SyncPathViewModelFromCoreRoute(PathRouteViewModel pathViewModel, PathRoute coreRoute, bool preserveSelection = true)
        {
            if (pathViewModel == null || coreRoute == null)
            {
                return false;
            }

            bool needsUpdate = !ReferenceEquals(pathViewModel.Route, coreRoute) ||
                               pathViewModel.Points.Count != coreRoute.Points.Count;

            if (!needsUpdate && pathViewModel.Points.Count == coreRoute.Points.Count)
            {
                for (int i = 0; i < pathViewModel.Points.Count; i++)
                {
                    var uiPoint = pathViewModel.Points[i];
                    var corePoint = coreRoute.Points[i];

                    if (uiPoint.Id != corePoint.Id ||
                        uiPoint.Name != corePoint.Name ||
                        uiPoint.Type != corePoint.Type)
                    {
                        needsUpdate = true;
                        break;
                    }

                    const double tolerance = 1e-6;
                    if (Math.Abs(uiPoint.X - corePoint.Position.X) > tolerance ||
                        Math.Abs(uiPoint.Y - corePoint.Position.Y) > tolerance ||
                        Math.Abs(uiPoint.Z - corePoint.Position.Z) > tolerance)
                    {
                        needsUpdate = true;
                        break;
                    }
                }
            }

            pathViewModel.Route = coreRoute;
            pathViewModel.SetTimeInfo(coreRoute.CreatedTime, coreRoute.LastModified);

            if (!needsUpdate)
            {
                pathViewModel.NotifyPropertyChanged(nameof(PathRouteViewModel.TotalLength));
                pathViewModel.NotifyPropertyChanged(nameof(PathRouteViewModel.LastModifiedTime));
                return false;
            }

            string selectedPointId = preserveSelection ? SelectedPathPoint?.Id : null;
            bool hadSelection = !string.IsNullOrEmpty(selectedPointId);
            PathPointViewModel newSelectedPoint = null;

            pathViewModel.Points.Clear();
            foreach (var pointViewModel in CreatePathPointViewModelsFromCoreRoute(coreRoute))
            {
                pathViewModel.Points.Add(pointViewModel);
                if (hadSelection && pointViewModel.Id == selectedPointId)
                {
                    newSelectedPoint = pointViewModel;
                }
            }

            pathViewModel.NotifyPropertyChanged(nameof(PathRouteViewModel.PointCount));
            pathViewModel.NotifyPropertyChanged(nameof(PathRouteViewModel.TotalLength));
            pathViewModel.NotifyPropertyChanged(nameof(PathRouteViewModel.SummaryInfo));
            pathViewModel.NotifyPropertyChanged(nameof(PathRouteViewModel.LastModifiedTime));

            if (hadSelection)
            {
                SelectedPathPoint = newSelectedPoint;
            }

            return true;
        }

        /// <summary>
        /// 更新吊装路径的关联点（UI层）
        /// </summary>
        /// <param name="pathRoute">路径</param>
        /// <param name="modifiedPointIndex">修改的点的索引</param>
        private void UpdateAerialPathRelatedPoints(PathRouteViewModel pathRoute, int modifiedPointIndex)
        {
            if (pathRoute.PathType != NavisworksTransport.PathType.Hoisting ||
                pathRoute.Points.Count != 4)
            {
                return;
            }

            var points = pathRoute.Points;

            // 修改起点（索引0）：更新提升点（索引1）的X,Y坐标
            if (modifiedPointIndex == 0)
            {
                var startPoint = points[0];
                var liftPoint = points[1];
                liftPoint.X = startPoint.X;
                liftPoint.Y = startPoint.Y;
            }
            // 修改终点（索引3）：更新平移终点（索引2）的X,Y坐标
            else if (modifiedPointIndex == 3)
            {
                var endPoint = points[3];
                var moveEndPoint = points[2];
                moveEndPoint.X = endPoint.X;
                moveEndPoint.Y = endPoint.Y;
            }
        }

        /// <summary>
        /// 更新吊装路径的关联点（Core层）
        /// </summary>
        /// <param name="coreRoute">Core路径</param>
        /// <param name="modifiedPointIndex">修改的点的索引</param>
        private void UpdateAerialPathRelatedPointsCore(PathRoute coreRoute, int modifiedPointIndex)
        {
            if (coreRoute.PathType != NavisworksTransport.PathType.Hoisting ||
                coreRoute.Points.Count != 4)
            {
                return;
            }

            var points = coreRoute.Points;

            // 修改起点（索引0）：更新提升点（索引1）的X,Y坐标
            if (modifiedPointIndex == 0)
            {
                var startPoint = points[0];
                var liftPoint = points[1];
                liftPoint.X = startPoint.X;
                liftPoint.Y = startPoint.Y;
            }
            // 修改终点（索引3）：更新平移终点（索引2）的X,Y坐标
            else if (modifiedPointIndex == 3)
            {
                var endPoint = points[3];
                var moveEndPoint = points[2];
                moveEndPoint.X = endPoint.X;
                moveEndPoint.Y = endPoint.Y;
            }
        }

        #endregion

        #region 自动路径规划命令

        private async Task ExecuteSelectStartPointAsync()
        {
            await SafeExecuteAsync(() =>
            {
                LogManager.Info("=== 开始执行选择起点命令 ===");

                if (_pathPlanningManager == null)
                {
                    LogManager.Error("PathPlanningManager为null，无法选择起点");
                    UpdateMainStatus("路径规划管理器未初始化");
                    return;
                }

                // 立即清理现有的起点标记（使用正确的路径ID）
                if (PathPointRenderPlugin.Instance != null && _autoPathStartPointRoute != null)
                {
                    PathPointRenderPlugin.Instance.RemovePath(_autoPathStartPointRoute.Id);
                    _autoPathStartPointRoute = null; // 清除引用
                }

                // 重置状态
                _hasStartPoint = false;
                AutoPathStartPoint = "未选择";

                LogManager.Info("PathPlanningManager已初始化，开始设置自动路径规划状态");
                IsSelectingStartPoint = true;
                IsSelectingEndPoint = false;

                // 通知按钮状态更新，禁用"手动创建"按钮
                OnPropertyChanged(nameof(CanExecuteNewPath));

                UpdateMainStatus("请在3D视图中点击选择起点...");

                // 进入自动路径规划模式 - 动态事件订阅
                LogManager.Info("进入自动路径规划模式，启用动态事件订阅");

                // 1. 禁用PathPlanningManager的鼠标处理
                _pathPlanningManager.DisableMouseHandling();

                // 2. 启用PathEditingViewModel的事件订阅
                PathClickToolPlugin.MouseClicked -= OnAutoPathMouseClicked; // 先取消避免重复
                PathClickToolPlugin.MouseClicked += OnAutoPathMouseClicked;
                LogManager.Info("已启用PathEditingViewModel的鼠标事件订阅");

                // 强制重新初始化ToolPlugin以确保获得鼠标焦点，自动路径不需要PathPlanningManager订阅事件
                if (!ForceReinitializeToolPlugin(subscribeToEvents: false))
                {
                    UpdateMainStatus("ToolPlugin初始化失败，请重试");
                    return;
                }

                // 在STA线程中调用Navisworks API
                _pathPlanningManager.StartClickTool(PathPointType.StartPoint);
                LogManager.Info("=== 选择起点命令设置完成，已启用动态事件订阅，等待用户点击 ===");
            }, "选择起点");
        }

        private async Task ExecuteSelectEndPointAsync()
        {
            await SafeExecuteAsync(() =>
            {
                LogManager.Info("=== 开始执行选择终点命令 ===");

                if (_pathPlanningManager == null)
                {
                    LogManager.Error("PathPlanningManager为null，无法选择终点");
                    UpdateMainStatus("路径规划管理器未初始化");
                    return;
                }

                // 立即清理现有的终点标记（使用正确的路径ID）
                if (PathPointRenderPlugin.Instance != null && _autoPathEndPointRoute != null)
                {
                    PathPointRenderPlugin.Instance.RemovePath(_autoPathEndPointRoute.Id);
                    LogManager.Debug($"[选择终点] 已清除之前的终点标记，ID: {_autoPathEndPointRoute.Id}");
                    _autoPathEndPointRoute = null; // 清除引用
                }

                // 重置状态
                _hasEndPoint = false;
                AutoPathEndPoint = "未选择";

                LogManager.Info("PathPlanningManager已初始化，开始设置自动路径规划状态");
                IsSelectingStartPoint = false;
                IsSelectingEndPoint = true;

                // 通知按钮状态更新，禁用"手动创建"按钮
                OnPropertyChanged(nameof(CanExecuteNewPath));

                UpdateMainStatus("请在3D视图中点击选择终点...");

                // 进入自动路径规划模式 - 动态事件订阅
                LogManager.Info("进入自动路径规划模式，启用动态事件订阅");

                // 1. 禁用PathPlanningManager的鼠标处理
                _pathPlanningManager.DisableMouseHandling();

                // 2. 启用PathEditingViewModel的事件订阅
                PathClickToolPlugin.MouseClicked -= OnAutoPathMouseClicked; // 先取消避免重复
                PathClickToolPlugin.MouseClicked += OnAutoPathMouseClicked;
                LogManager.Info("已启用PathEditingViewModel的鼠标事件订阅");

                // 强制重新初始化ToolPlugin以确保获得鼠标焦点，自动路径不需要PathPlanningManager订阅事件
                if (!ForceReinitializeToolPlugin(subscribeToEvents: false))
                {
                    UpdateMainStatus("ToolPlugin初始化失败，请重试");
                    return;
                }

                // 在STA线程中调用Navisworks API
                _pathPlanningManager.StartClickTool(PathPointType.EndPoint);
                LogManager.Info("=== 选择终点命令设置完成，已启用动态事件订阅，等待用户点击 ===");
            }, "选择终点");
        }

        private async Task ExecuteAutoPlanPathAsync()
        {
            await SafeExecuteAsync(async () =>
            {
                // 保存当前光标
                var oldCursor = Mouse.OverrideCursor;

                try
                {
                    if (!_hasStartPoint || !_hasEndPoint)
                    {
                        UpdateMainStatus("请先选择起点和终点");
                        return;
                    }

                    // 设置等待光标
                    Mouse.OverrideCursor = Cursors.Wait;

                    UpdateMainStatus("正在计算最优路径...", -1, true);
                    LogManager.Info("=== 开始执行自动路径规划 ===");

                // 确保在开始自动路径规划前清理任何残留的事件订阅
                CleanupAutoPathEventSubscriptions();
                if (_pathPlanningManager != null)
                {
                    _pathPlanningManager.StopClickTool();
                }

                // 清理所有临时路径，确保干净的起始状态
                ClearTemporaryAutoPathMarkers();
                if (PathPointRenderPlugin.Instance != null)
                {
                    // 检查是否有网格可视化启用，只在启用时保留网格可视化路径
                    if (_pathPlanningManager?.IsAnyGridVisualizationEnabled == true)
                    {
                        PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                    }
                    else
                    {
                        PathPointRenderPlugin.Instance.ClearPathsExcept(); // 清理所有路径，不保留任何内容
                    }
                }

                // 调用PathPlanningManager的自动路径规划功能
                var startPathPoint = new PathPoint
                {
                    Name = "自动起点",
                    Position = _startPoint3D,
                    Type = PathPointType.StartPoint
                };
                var endPathPoint = new PathPoint
                {
                    Name = "自动终点",
                    Position = _endPoint3D,
                    Type = PathPointType.EndPoint
                };

                LogManager.Info($"起点: ({_startPoint3D.X:F2}, {_startPoint3D.Y:F2}, {_startPoint3D.Z:F2})");
                LogManager.Info($"终点: ({_endPoint3D.X:F2}, {_endPoint3D.Y:F2}, {_endPoint3D.Z:F2})");

                // 计算物体半径：基于长度和宽度的较大值的一半，高度暂时不参与半径计算
                var objectRadius = Math.Max(ObjectLength, ObjectWidth) / 2.0;

                LogManager.Info($"物体参数: 长{ObjectLength:F1}m × 宽{ObjectWidth:F1}m × 高{ObjectHeight:F1}m");
                LogManager.Info($"计算得出物体半径: {objectRadius:F2}m (基于长宽较大值的一半)");

                // 确定网格大小：如果启用手动设置则使用用户设置的值，否则使用-1（自动选择）
                var gridSize = IsGridSizeManuallyEnabled ? GridSize : -1;

                // 获取选择的路径策略，如果未选择则默认使用最短路径
                var selectedStrategy = SelectedPathStrategy?.Value ?? PathStrategy.Shortest;

                LogManager.Info($"网格大小设置: {(IsGridSizeManuallyEnabled ? $"手动设置 {GridSize:F1}米" : "自动选择")}");
                LogManager.Info($"路径策略: {SelectedPathStrategy?.DisplayName ?? "最短路径"}");

                // 在STA线程中执行Navisworks API调用
                var pathRoute = await _pathPlanningManager?.AutoPlanPath(startPathPoint, endPathPoint, objectRadius, SafetyMargin, gridSize, ObjectHeight, selectedStrategy);

                if (pathRoute != null && pathRoute.Points.Count > 0)
                {
                    LogManager.Info($"路径规划成功，共 {pathRoute.Points.Count} 个点");

                    // 自动路径规划完成后，执行完整的事件订阅清理
                    CleanupAutoPathEventSubscriptions();
                    if (_pathPlanningManager != null)
                    {
                        _pathPlanningManager.StopClickTool();
                    }

                    // 清理临时的起点和终点标记
                    ClearTemporaryAutoPathMarkers();

                    // 不在这里直接操作UI，让RouteGenerated事件处理UI更新
                    // 这避免了重复的路径添加和UI更新冲突

                    // 不在这里设置状态，让RouteGenerated事件处理UI更新
                    LogManager.Info($"✅ 自动路径规划完成，RouteGenerated事件将处理UI更新");
                }
                else
                {
                    // 这里的逻辑已经在上方处理过了

                    // 失败情况下也要清理事件订阅和临时标记
                    CleanupAutoPathEventSubscriptions();
                    if (_pathPlanningManager != null)
                    {
                        _pathPlanningManager.StopClickTool();
                    }

                    // 清理临时的起点和终点标记
                    ClearTemporaryAutoPathMarkers();

                    // 确保失败后也清理所有可能的残留路径对象
                    if (PathPointRenderPlugin.Instance != null)
                    {
                        // 检查是否有网格可视化启用，只在启用时保留网格可视化路径
                        if (_pathPlanningManager?.IsAnyGridVisualizationEnabled == true)
                        {
                            PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                        }
                        else
                        {
                            PathPointRenderPlugin.Instance.ClearPathsExcept(); // 清理所有路径，不保留任何内容
                        }
                    }
                }
                }
                finally
                {
                    // 恢复光标
                    Mouse.OverrideCursor = oldCursor;
                }
            }, "自动路径规划");
        }

        private async Task ExecuteClearAutoPathAsync()
        {
            // 使用基类的SafeExecuteAsync方法，确保在STA线程上执行
            await SafeExecuteAsync(() =>
            {
                LogManager.Info("=== 开始重置自动路径规划状态 ===");

                // 停止任何正在进行的点选择
                if (_pathPlanningManager != null)
                {
                    _pathPlanningManager.StopClickTool();
                    PathClickToolPlugin.MouseClicked -= OnAutoPathMouseClicked;
                }

                // 清除所有路径的可视化显示（与新建路径按钮保持一致）
                if (PathPointRenderPlugin.Instance != null)
                {
                    try
                    {
                        // 清除路径可视化，但保留网格可视化
                        PathPointRenderPlugin.Instance.ClearPathsExcept("grid_visualization_all", "grid_visualization_channel", "grid_visualization_unknown", "grid_visualization_obstacle", "grid_visualization_door");
                        LogManager.Info("重置参数：已清除路径可视化显示（保留网格可视化）");
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"重置参数：清除路径可视化失败: {ex.Message}", ex);
                        // 不抛出异常，继续执行状态重置
                    }
                }

                // 强制重新初始化ToolPlugin以重新获得鼠标焦点，重置时不需要订阅事件
                if (_pathPlanningManager != null)
                {
                    ForceReinitializeToolPlugin(subscribeToEvents: false);
                }

                // 重置所有状态
                _hasStartPoint = false;
                _hasEndPoint = false;
                _startPoint3D = new Point3D();
                _endPoint3D = new Point3D();
                AutoPathStartPoint = "未选择";
                AutoPathEndPoint = "未选择";
                UpdateMainStatus("就绪");
                IsSelectingStartPoint = false;
                IsSelectingEndPoint = false;

                // 清除路径引用
                _autoPathStartPointRoute = null;
                _autoPathEndPointRoute = null;

                // 通知Can Execute属性更改
                OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                OnPropertyChanged(nameof(CanExecuteNewPath));

                LogManager.Info("自动路径规划参数和起终点标记已完全重置，ToolPlugin已重新初始化");
            }, "重置自动路径规划");
        }

        #endregion

        #region 路径编辑命令 - 待实现

        private async Task ExecuteRenamePathAsync()
        {
            if (SelectedPathRoute == null) return;

            await SafeExecuteAsync(async () =>
            {
                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    // TODO: 实现重命名对话框
                    var newName = $"路径 {PathRoutes.Count}";
                    var oldName = SelectedPathRoute.Name;
                    SelectedPathRoute.Name = newName;
                    UpdateMainStatus($"路径已重命名: {oldName} -> {newName}");
                });
            }, "重命名路径");
        }

        private async Task ExecuteAddPathPointAsync()
        {
            if (!CanExecuteStartEdit) return;

            await SafeExecuteAsync(async () =>
            {
                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    IsPathEditMode = true;
                    if (SelectedPathRoute != null)
                    {
                        SelectedPathRoute.IsActive = true;
                        UpdateMainStatus($"正在激活3D路径编辑模式: {SelectedPathRoute.Name}...");

                        // 检查是否是空轨路径
                        bool isRailPath = SelectedPathRoute.PathType == PathType.Rail;

                        // 启动PathPlanningManager的点击工具，这会设置正确的编辑状态
                        if (_pathPlanningManager != null)
                        {
                            try
                            {
                                if (isRailPath)
                                {
                                    _pathPlanningManager.StartClickTool(PathPointType.WayPoint, enableRailSnapping: true);
                                    LogManager.Info($"已启动PathPlanningManager点击工具（空轨吸附模式）: {SelectedPathRoute.Name}");
                                }
                                else
                                {
                                    _pathPlanningManager.StartClickTool(PathPointType.WayPoint);
                                    LogManager.Info($"已启动PathPlanningManager点击工具: {SelectedPathRoute.Name}");
                                }
                            }
                            catch (Exception ex)
                            {
                                LogManager.Error($"启动点击工具失败: {ex.Message}");
                                UpdateMainStatus("启动3D编辑工具失败，请重试");
                                IsPathEditMode = false;
                                return;
                            }
                        }
                        else
                        {
                            UpdateMainStatus("路径规划管理器未初始化");
                            LogManager.Error("添加路径点：PathPlanningManager未初始化");
                            IsPathEditMode = false;
                            return;
                        }

                        string modeText = isRailPath ? "（空轨吸附模式）" : "";
                        UpdateMainStatus($"已进入3D路径编辑模式: {SelectedPathRoute.Name} {modeText} - 在3D视图中点击设置路径点");
                        LogManager.Info($"开始添加路径点: {SelectedPathRoute.Name}，已启动点击工具");

                        // 手动触发按钮状态更新
                        OnPropertyChanged(nameof(CanExecuteStartEdit));
                        OnPropertyChanged(nameof(CanExecuteEndEdit));
                    }
                });
            }, "添加路径点");
        }

        private async Task ExecuteEndEditAsync()
        {
            if (!CanExecuteEndEdit) return;

            if ((_pathPlanningManager == null || _pathPlanningManager.PathEditState == PathEditState.Viewing) &&
                CanCancelRailAssemblyWorkflow)
            {
                ExecuteCancelRailAssemblyWorkflow();
                return;
            }

            await SafeExecuteAsync(async () =>
            {
                bool success = false;
                string operationMessage = "";
                bool wasInPreviewMode = false;

                if (_pathPlanningManager != null)
                {
                    // 检查是否在修改路径点模式
                    bool isEditingPoint = _pathPlanningManager.PathEditState == PathEditState.EditingPoint;

                    if (isEditingPoint)
                    {
                        // 修改路径点模式 - 尝试确认修改
                        success = _pathPlanningManager.UpdatePointPosition();
                        if (success)
                        {
                            operationMessage = "路径点修改已确认";
                        }
                        else
                        {
                            // 确认失败（可能没有预览点），执行取消操作以安全退出
                            success = _pathPlanningManager.CancelEditPoint();
                            operationMessage = success ? "已取消路径点修改" : "取消路径点修改失败";
                        }
                        LogManager.Info($"[UI-修改路径点] {operationMessage}");
                    }
                    else
                    {
                        // 记录是否在预览模式（因为确认预览点后会退出预览模式）
                        wasInPreviewMode = _pathPlanningManager.IsPreviewMode;

                        if (wasInPreviewMode)
                        {
                            // 预览模式 - 先确认预览点，然后立即完成编辑
                            var confirmedPoint = _pathPlanningManager.ConvertPreviewToPathPoint();
                            if (confirmedPoint != null)
                            {
                                LogManager.Info($"[UI-预览模式] 预览点已确认: {confirmedPoint.Name}，现在完成编辑");

                                // 立即完成编辑，不让用户继续添加点
                                success = _pathPlanningManager.FinishEditing();
                                operationMessage = success ? $"预览点已确认并完成编辑: {confirmedPoint.Name}" : "预览点确认后完成编辑失败";
                            }
                            else
                            {
                                LogManager.Error("[UI-预览模式] 预览点确认失败");
                                operationMessage = "预览点确认失败";
                                success = false;
                            }

                            LogManager.Info($"[UI-预览模式] {operationMessage}");
                        }
                        else
                        {
                            // 普通模式 - 直接完成编辑
                            success = _pathPlanningManager.FinishEditing();
                            operationMessage = success ? "路径编辑完成" : "路径编辑完成失败";

                            LogManager.Info($"[UI-编辑模式] {operationMessage}");
                        }
                    }
                }

                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    if (success)
                    {
                        // 编辑完成成功
                        if (SelectedPathRoute != null)
                        {
                            if (_pathPlanningManager?.PathEditState == PathEditState.EditingPoint || operationMessage.Contains("路径点修改"))
                            {
                                UpdateMainStatus($"✅ 路径点修改完成: {SelectedPathRoute.Name}");
                            }
                            else if (wasInPreviewMode)
                            {
                                UpdateMainStatus($"✅ 预览点已确认，路径编辑完成: {SelectedPathRoute.Name}");
                            }
                            else
                            {
                                UpdateMainStatus($"✅ 路径编辑完成: {SelectedPathRoute.Name} - 最后一个点已自动设置为终点");
                            }
                        }

                        LogManager.Info("[UI状态] 路径编辑完成，等待状态变更事件更新按钮");
                    }
                    else
                    {
                        // 编辑完成失败
                        if (SelectedPathRoute != null)
                        {
                            UpdateMainStatus($"❌ 路径编辑失败: {SelectedPathRoute.Name}");
                        }

                        LogManager.Error("[UI状态] 路径编辑失败");
                    }

                    // 手动触发按钮状态更新 - 确保UI及时响应
                    OnPropertyChanged(nameof(CanExecuteStartEdit));
                    OnPropertyChanged(nameof(CanExecuteEndEdit));
                    OnPropertyChanged(nameof(CanExecuteCancelModifyPoint));
                });
            }, "结束路径编辑");
        }

        private async Task ExecuteClearPathAsync()
        {
            if (!CanExecuteClearPath) return;

            await SafeExecuteAsync(async () =>
            {
                var pointCount = SelectedPathRoute.Points.Count;

                // 清空 Core 层的路径点
                var coreRoute = _pathPlanningManager?.Routes?.FirstOrDefault(r => r.Name == SelectedPathRoute.Name);
                if (coreRoute != null)
                {
                    coreRoute.Points.Clear();
                    coreRoute.RecalculateAndSaveRoute("清空路径");
                    LogManager.Info($"已清空Core路径: {coreRoute.Name}");
                }

                // 清空 UI 层的路径点
                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    SelectedPathRoute.Points.Clear();
                    UpdateMainStatus($"已清空路径 {SelectedPathRoute.Name} 的 {pointCount} 个点");
                });
            }, "清空路径");
        }

        private async Task ExecuteDeletePointAsync(PathPointViewModel point)
        {
            if (SelectedPathRoute == null || point == null) return;

            await SafeExecuteAsync(async () =>
            {
                // 1. 查找对应的Core数据
                var coreRoute = _pathPlanningManager?.Routes?.FirstOrDefault(r => r.Name == SelectedPathRoute.Name);
                if (coreRoute == null)
                {
                    LogManager.Warning($"未找到对应的Core路径: {SelectedPathRoute.Name}");
                    return;
                }

                // 2. 路径完整性验证：检查删除后是否至少还有2个点
                if (coreRoute.Points.Count <= 2)
                {
                    LogManager.Warning($"路径点不足，无法删除。当前路径只有{coreRoute.Points.Count}个点，至少需要保留2个点（起点和终点）");
                    UpdateMainStatus($"❌ 无法删除路径点：路径至少需要保留2个点（起点和终点），当前只有{coreRoute.Points.Count}个点");
                    return;
                }

                // 3. 在Core路径中查找对应的点（通过位置和名称匹配）
                var corePoint = coreRoute.Points.FirstOrDefault(p =>
                    p.Name == point.Name &&
                    Math.Abs(p.Position.X - point.X) < 0.001 &&
                    Math.Abs(p.Position.Y - point.Y) < 0.001 &&
                    Math.Abs(p.Position.Z - point.Z) < 0.001);

                if (corePoint == null)
                {
                    LogManager.Warning($"未找到对应的Core路径点: {point.Name}");
                    // 即使Core数据不匹配，也要更新UI数据保持一致性
                }

                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    // 4. 禁止删除起点和终点
                    if (corePoint != null)
                    {
                        int pointIndex = coreRoute.Points.IndexOf(corePoint);

                        if (corePoint.Type == PathPointType.StartPoint)
                        {
                            LogManager.Warning($"不能删除路径的起点");
                            UpdateMainStatus($"❌ 无法删除：{corePoint.Name} 是路径的起点");
                            return;
                        }

                        if (corePoint.Type == PathPointType.EndPoint)
                        {
                            LogManager.Warning($"不能删除路径的终点");
                            UpdateMainStatus($"❌ 无法删除：{corePoint.Name} 是路径的终点");
                            return;
                        }

                        // 吊装路径：禁止删除关键点（提升点、下降点）
                        if (coreRoute.PathType == PathType.Hoisting &&
                            (corePoint.Name == "提升点" || corePoint.Name == "下降点"))
                        {
                            LogManager.Warning($"不能删除吊装路径的关键点: {corePoint.Name}");
                            UpdateMainStatus($"❌ 无法删除：{corePoint.Name} 是吊装路径的关键点");
                            return;
                        }

                        // 删除Core数据
                        coreRoute.Points.Remove(corePoint);
                        LogManager.Info($"已从Core数据删除路径点: {corePoint.Name}");

                        // 吊装路径：正交化路径（处理斜线和清除多余点）
                        if (coreRoute.PathType == PathType.Hoisting)
                        {
                            _pathPlanningManager?.OrthogonalizePath(coreRoute);
                            
                            // 吊装路径：检测并移除矩形环路
                            LogManager.Info($"[吊装路径] 删除路径点后检测矩形环路");
                            _pathPlanningManager?.RemoveRectangularLoops(coreRoute);
                        }

                        // 调用PathPlanningManager的3D删除方法
                        _pathPlanningManager.RemovePathPoint(corePoint);

                        // 触发UI同步更新事件
                        _pathPlanningManager.RaisePathPointsListUpdated(coreRoute, "删除路径点并重新分配类型");
                        LogManager.Info("已触发PathPointsListUpdated事件，UI将自动同步");
                    }

                    // 5. 删除UI数据（事件驱动会自动处理，这里只作为备份）
                    SelectedPathRoute.Points.Remove(point);
                    LogManager.Info($"已从UI删除路径点: {point.Name}");

                    // 🔥 如果被删除的点是当前选中的点，清空选中状态
                    if (SelectedPathPoint != null && SelectedPathPoint.Id == point.Id)
                    {
                        SelectedPathPoint = null;
                        LogManager.Info("已清空选中状态（删除的是当前选中的点）");
                    }

                    // 6. 更新UI状态
                    UpdateMainStatus($"✅ 已删除路径点: {point.Name}");

                    LogManager.Info($"路径点删除完成，当前UI点数: {SelectedPathRoute.Points.Count}, Core点数: {coreRoute?.Points.Count ?? 0}");
                });

                // 7. 刷新3D可视化显示（路径变更会自动更新可视化）
                UpdatePathVisualization();
                LogManager.Info("已触发路径可视化更新");

            }, "删除路径点");
        }

        private async Task ExecuteModifyPointAsync()
        {
            if (!CanExecuteModifyPoint) return;

            await SafeExecuteAsync(async () =>
            {
                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    if (SelectedPathPoint != null && _pathPlanningManager != null)
                    {
                        // 获取选中路径点的索引
                        var currentRoute = _pathPlanningManager.CurrentRoute;
                        if (currentRoute != null && currentRoute.Points != null)
                        {
                            int pointIndex = -1;

                            // 详细调试信息
                            LogManager.Info($"开始查找路径点索引 - 选中点Id: {SelectedPathPoint.Id}, 选中点名称: {SelectedPathPoint.Name}");
                            LogManager.Info($"当前路径包含 {currentRoute.Points.Count} 个路径点");

                            // 遍历查找匹配的Id
                            for (int i = 0; i < currentRoute.Points.Count; i++)
                            {
                                var currentPoint = currentRoute.Points[i];
                                //LogManager.Info($"检查路径点 [{i}] - Id: {currentPoint.Id}, 名称: {currentPoint.Name}");

                                if (currentPoint.Id == SelectedPathPoint.Id)
                                {
                                    pointIndex = i;
                                    LogManager.Info($"找到匹配的路径点，索引: {pointIndex}");
                                    break;
                                }
                            }

                            if (pointIndex >= 0)
                            {
                                // 调用PathPlanningManager开始修改路径点
                                bool success = _pathPlanningManager.StartEditingPoint(pointIndex);

                                if (success)
                                {
                                    UpdateMainStatus($"正在修改路径点: {SelectedPathPoint.Name} - 请在3D视图中点击新位置");
                                    LogManager.Info($"已开始修改路径点: {SelectedPathPoint.Name}, 索引: {pointIndex}");

                                    // 刷新命令状态
                                    OnPropertyChanged(nameof(CanExecuteStartEdit));
                                    OnPropertyChanged(nameof(CanExecuteEndEdit));
                                    OnPropertyChanged(nameof(CanExecuteModifyPoint));
                                    OnPropertyChanged(nameof(CanExecuteCancelModifyPoint));
                                }
                                else
                                {
                                    UpdateMainStatus("修改路径点失败，请检查路径状态");
                                    LogManager.Error($"开始修改路径点失败: {SelectedPathPoint.Name}, 索引: {pointIndex}");
                                }
                            }
                            else
                            {
                                UpdateMainStatus("找不到选中的路径点");
                                LogManager.Error($"找不到路径点索引 - 选中点Id: {SelectedPathPoint.Id}, 选中点名称: {SelectedPathPoint.Name}");
                                LogManager.Error("可能原因：1)选中的路径点与当前路径不匹配 2)路径点数据不同步 3)Id不匹配");
                            }
                        }
                        else
                        {
                            if (currentRoute == null)
                            {
                                UpdateMainStatus("当前没有活动路径");
                                LogManager.Error("尝试修改路径点时没有当前路径");
                            }
                            else
                            {
                                UpdateMainStatus("当前路径没有路径点数据");
                                LogManager.Error("当前路径的Points集合为空");
                            }
                        }
                    }
                    else
                    {
                        if (SelectedPathPoint == null)
                        {
                            UpdateMainStatus("请先选中要修改的路径点");
                            LogManager.Warning("修改路径点时没有选中路径点");
                        }
                        else
                        {
                            UpdateMainStatus("路径规划管理器未初始化");
                            LogManager.Error("修改路径点时PathPlanningManager为空");
                        }
                    }
                });
            }, "修改路径点");
        }

        /// <summary>
        /// 取消修改路径点
        /// </summary>
        private async Task ExecuteCancelModifyPointAsync()
        {
            if (!CanExecuteCancelModifyPoint) return;

            await SafeExecuteAsync(async () =>
            {
                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    if (_pathPlanningManager != null)
                    {
                        // 调用PathPlanningManager取消修改路径点
                        bool success = _pathPlanningManager.CancelEditPoint();

                        if (success)
                        {
                            UpdateMainStatus("已取消修改路径点");
                            LogManager.Info("用户取消了修改路径点操作");
                        }
                        else
                        {
                            UpdateMainStatus("取消修改路径点失败");
                            LogManager.Error("取消修改路径点失败");
                        }

                        // 刷新命令状态
                        OnPropertyChanged(nameof(CanExecuteStartEdit));
                        OnPropertyChanged(nameof(CanExecuteEndEdit));
                        OnPropertyChanged(nameof(CanExecuteModifyPoint));
                        OnPropertyChanged(nameof(CanExecuteCancelModifyPoint));
                    }
                });
            }, "取消修改路径点");
        }

        #endregion

        #region 文件管理命令

        private async Task ExecuteImportPathAsync()
        {
            await SafeExecuteAsync(async () =>
            {
                try
                {
                    // 打开文件选择对话框
                    var openFileDialog = new OpenFileDialog
                    {
                        Title = "导入路径文件",
                        Filter = "路径文件 (*.xml;*.json)|*.xml;*.json|XML文件 (*.xml)|*.xml|JSON文件 (*.json)|*.json|所有文件 (*.*)|*.*",
                        FilterIndex = 1,
                        CheckFileExists = true,
                        CheckPathExists = true
                    };

                    if (openFileDialog.ShowDialog() == true)
                    {
                        var filePath = openFileDialog.FileName;
                        var extension = Path.GetExtension(filePath).ToLower();

                        // 确定导入格式
                        ExportFormat importFormat;
                        switch (extension)
                        {
                            case ".json":
                                importFormat = ExportFormat.Json;
                                break;
                            case ".csv":
                                importFormat = ExportFormat.Csv;
                                break;
                            default:
                                importFormat = ExportFormat.Xml;
                                break;
                        }

                        // 创建导入参数
                        var importParameters = new ImportPathParameters
                        {
                            FilePath = filePath,
                            ImportFormat = importFormat,
                            MergeWithExisting = true,
                            CreateBackup = true,
                            DuplicateHandling = DuplicateNameHandling.Rename,
                            ValidateImportedData = true,
                            AutoSelectFirstRoute = true,
                            Description = $"导入路径文件: {Path.GetFileName(filePath)}"
                        };

                        // 创建并执行导入命令
                        var importCommand = new ImportPathCommand(importParameters, _pathPlanningManager);
                        var result = await importCommand.ExecuteAsync();

                        if (result.IsSuccess)
                        {
                            // 更新UI状态
                            RefreshPathRoutes();

                            // 如果需要自动选择第一个导入的路径，通过专门的选择逻辑处理
                            if (importParameters.AutoSelectFirstRoute && PathRoutes.Count > 0)
                            {
                                var firstRoute = PathRoutes.FirstOrDefault();
                                if (firstRoute != null)
                                {
                                    SelectedPathRoute = firstRoute;
                                    LogManager.Info($"导入完成后自动选择路径: {firstRoute.Name}");
                                }
                            }

                            var importResult = (result as PathPlanningResult<ImportPathResult>)?.Data;
                            if (importResult != null)
                            {
                                var statusMessage = $"✅ 导入成功: {importResult.ImportedCount}/{importResult.TotalInFile} 个路径";
                                if (importResult.FailedCount > 0)
                                {
                                    statusMessage += $" (失败 {importResult.FailedCount} 个)";
                                }
                                UpdateMainStatus(statusMessage);
                                if (!string.IsNullOrEmpty(importResult.BackupFilePath))
                                {
                                    LogManager.Info($"导入前备份已创建: {importResult.BackupFilePath}");
                                }
                            }
                            else
                            {
                                UpdateMainStatus($"✅ 路径导入完成: {Path.GetFileName(filePath)}");
                            }
                        }
                        else
                        {
                            UpdateMainStatus($"❌ 导入失败: {result.ErrorMessage}");
                            LogManager.Error($"路径导入失败: {result.ErrorMessage}");
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Error($"导入路径异常: {ex.Message}", ex);
                    UpdateMainStatus($"❌ 导入异常: {ex.Message}");
                }
            }, "导入路径");
        }

        private async Task ExecuteExportPathAsync()
        {
            if (!CanExecuteExportPath) return;

            await SafeExecuteAsync(async () =>
            {
                try
                {
                    // 打开文件保存对话框
                    var saveFileDialog = new SaveFileDialog
                    {
                        Title = "导出全部路径",
                        Filter = "XML文件 (*.xml)|*.xml|JSON文件 (*.json)|*.json|CSV文件 (*.csv)|*.csv|DELMIA Apriso XML (*.aprxml)|*.aprxml|所有文件 (*.*)|*.*",
                        FilterIndex = 1,
                        FileName = $"路径导出_{DateTime.Now:yyyyMMdd_HHmmss}",
                        DefaultExt = "xml",
                        AddExtension = true
                    };

                    if (saveFileDialog.ShowDialog() == true)
                    {
                        var filePath = saveFileDialog.FileName;
                        
                        // 确定导出格式（通过FilterIndex判断，因为DELMIA Apriso和普通XML都是.xml扩展名）
                        ExportFormat exportFormat;
                        switch (saveFileDialog.FilterIndex)
                        {
                            case 2: // JSON文件
                                exportFormat = ExportFormat.Json;
                                break;
                            case 3: // CSV文件
                                exportFormat = ExportFormat.Csv;
                                break;
                            case 4: // DELMIA Apriso XML
                                exportFormat = ExportFormat.DelmiaApriso;
                                break;
                            default: // XML文件或其他
                                exportFormat = ExportFormat.Xml;
                                break;
                        }

                        // 创建导出参数 - 导出所有路径
                        var exportParameters = new ExportPathParameters
                        {
                            ExportAll = true,
                            OutputFilePath = filePath,
                            ExportFormat = exportFormat,
                            OverwriteExisting = true,
                            ValidateExportData = true,
                            GenerateReport = false,
                            Description = $"导出全部路径到: {Path.GetFileName(filePath)}"
                        };

                        // 创建并执行导出命令
                        var exportCommand = new ExportPathCommand(exportParameters, _pathPlanningManager);
                        var result = await exportCommand.ExecuteAsync();

                        if (result.IsSuccess)
                        {
                            var exportResult = (result as PathPlanningResult<ExportPathResult>)?.Data;
                            if (exportResult != null)
                            {
                                var statusMessage = $"✅ 导出全部成功: {exportResult.ExportedCount} 个路径到 {Path.GetFileName(filePath)}";
                                if (exportResult.FailedCount > 0)
                                {
                                    statusMessage += $" (失败 {exportResult.FailedCount} 个)";
                                }
                                UpdateMainStatus(statusMessage);
                                LogManager.Info($"导出完成，文件大小: {exportResult.FileSizeMB:F2} MB");
                            }
                            else
                            {
                                UpdateMainStatus($"✅ 全部路径导出完成: {Path.GetFileName(filePath)}");
                            }
                        }
                        else
                        {
                            UpdateMainStatus($"❌ 导出全部失败: {result.ErrorMessage}");
                            LogManager.Error($"全部路径导出失败: {result.ErrorMessage}");
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Error($"导出全部路径异常: {ex.Message}", ex);
                    UpdateMainStatus($"❌ 导出全部异常: {ex.Message}");
                }
            }, "导出全部路径");
        }

        private async Task ExecuteSaveAsPathAsync()
        {
            if (!CanExecuteSaveAsPath) return;

            await SafeExecuteAsync(async () =>
            {
                try
                {
                    // 打开文件保存对话框
                    var saveFileDialog = new SaveFileDialog
                    {
                        Title = $"导出选中路径: {SelectedPathRoute?.Name}",
                        Filter = "XML文件 (*.xml)|*.xml|JSON文件 (*.json)|*.json|CSV文件 (*.csv)|*.csv|DELMIA Apriso XML (*.aprxml)|*.aprxml|所有文件 (*.*)|*.*",
                        FilterIndex = 1,
                        FileName = SelectedPathRoute?.Name?.Replace(" ", "_") ?? "路径",
                        DefaultExt = "xml",
                        AddExtension = true
                    };

                    if (saveFileDialog.ShowDialog() == true)
                    {
                        var filePath = saveFileDialog.FileName;
                        
                        // 确定导出格式（通过FilterIndex判断，因为DELMIA Apriso和普通XML都是.xml扩展名）
                        ExportFormat exportFormat;
                        switch (saveFileDialog.FilterIndex)
                        {
                            case 2: // JSON文件
                                exportFormat = ExportFormat.Json;
                                break;
                            case 3: // CSV文件
                                exportFormat = ExportFormat.Csv;
                                break;
                            case 4: // DELMIA Apriso XML
                                exportFormat = ExportFormat.DelmiaApriso;
                                break;
                            default: // XML文件或其他
                                exportFormat = ExportFormat.Xml;
                                break;
                        }

                        // 查找当前选中路径对应的Core路径
                        var coreRoute = _pathPlanningManager.Routes.FirstOrDefault(r => r.Name == SelectedPathRoute.Name);
                        if (coreRoute != null)
                        {
                            // 创建导出参数 - 只导出当前选中的路径
                            var exportParameters = new ExportPathParameters
                            {
                                PathsToExport = new System.Collections.Generic.List<PathRoute> { coreRoute },
                                OutputFilePath = filePath,
                                ExportFormat = exportFormat,
                                OverwriteExisting = true,
                                ValidateExportData = true,
                                GenerateReport = false,
                                Description = $"导出选中路径: {SelectedPathRoute.Name}"
                            };

                            // 创建并执行导出命令
                            var exportCommand = new ExportPathCommand(exportParameters, _pathPlanningManager);
                            var result = await exportCommand.ExecuteAsync();

                            if (result.IsSuccess)
                            {
                                var exportResult = (result as PathPlanningResult<ExportPathResult>)?.Data;
                                if (exportResult != null)
                                {
                                    UpdateMainStatus($"✅ 导出选中路径成功: {SelectedPathRoute.Name} -> {Path.GetFileName(filePath)}");
                                    LogManager.Info($"导出选中路径完成，文件大小: {exportResult.FileSizeMB:F2} MB");
                                }
                                else
                                {
                                    UpdateMainStatus($"✅ 导出选中路径完成: {Path.GetFileName(filePath)}");
                                }
                            }
                            else
                            {
                                UpdateMainStatus($"❌ 导出选中路径失败: {result.ErrorMessage}");
                                LogManager.Error($"导出选中路径失败: {result.ErrorMessage}");
                            }
                        }
                        else
                        {
                            UpdateMainStatus($"❌ 导出选中路径失败：找不到对应的Core路径: {SelectedPathRoute.Name}");
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Error($"导出选中路径异常: {ex.Message}", ex);
                    UpdateMainStatus($"❌ 导出选中路径异常: {ex.Message}");
                }
            }, "导出选中路径");
        }

        /// <summary>
        /// 生成导航地图的纯业务逻辑方法
        /// </summary>
        /// <param name="renderStyle">渲染样式</param>
        /// <param name="width">图像宽度</param>
        /// <param name="height">图像高度</param>
        /// <param name="format">图像格式</param>
        /// <returns>生成的图像数据</returns>
        public Bitmap GenerateNavigationMap(ImageGenerationStyle renderStyle, int width, int height, ImageFormat format)
        {
            try
            {
                LogManager.Info($"开始生成导航地图: 样式={renderStyle}, 尺寸={width}x{height}, 格式={format}");

                // 创建导航地图生成器
                var generator = new NavigationMapGenerator();

                // 生成图像
                var bitmap = generator.GenerateNavigationMapImage(renderStyle, width, height);

                LogManager.Info($"导航地图生成成功: {width}x{height}像素");
                return bitmap;
            }
            catch (Exception ex)
            {
                LogManager.Error($"生成导航地图失败: {ex.Message}", ex);
                throw;
            }
        }


        /// <summary>
        /// 刷新路径集合显示
        /// </summary>
        private void RefreshPathRoutes()
        {
            try
            {
                if (_pathPlanningManager?.Routes != null)
                {
                    // 清除现有的UI路径
                    PathRoutes.Clear();

                    // 重新加载所有路径
                    foreach (var coreRoute in _pathPlanningManager.Routes)
                    {
                        var pathViewModel = new PathRouteViewModel(isFromDatabase: true)
                        {
                            Route = coreRoute,
                            IsActive = false
                        };

                        // 设置时间信息
                        pathViewModel.SetTimeInfo(coreRoute.CreatedTime, coreRoute.LastModified);

                        // 使用统一的辅助方法创建路径点
                        var pathPoints = CreatePathPointViewModelsFromCoreRoute(coreRoute);
                        foreach (var point in pathPoints)
                        {
                            pathViewModel.Points.Add(point);
                        }

                        PathRoutes.Add(pathViewModel);
                        LogManager.Info($"RefreshPathRoutes: 添加路径ViewModel {coreRoute.Name} (Hash: {pathViewModel.GetHashCode()})");
                    }

                    LogManager.Info($"已刷新路径集合显示，共 {PathRoutes.Count} 个路径");

                    // 调试：列出所有PathRoutes中的路径名称和哈希码
                    for (int i = 0; i < PathRoutes.Count; i++)
                    {
                        var route = PathRoutes[i];
                        LogManager.Info($"  PathRoutes[{i}]: {route.Name} (Hash: {route.GetHashCode()}, Points: {route.Points.Count})");
                    }
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"刷新路径集合失败: {ex.Message}", ex);
            }
        }

        #endregion

        #endregion

        #region 事件处理

        /// <summary>
        /// 处理自动路径规划的鼠标点击事件
        /// </summary>
        private async void OnAutoPathMouseClicked(object sender, PickItemResult pickResult)
        {
            try
            {
                if (pickResult == null)
                {
                    return;
                }

                var point3D = pickResult.Point;

                if (IsSelectingStartPoint)
                {
                    SetAutoPathStartPoint(point3D);
                    await SafeExecuteAsync(() =>
                    {
                        // 退出自动路径规划模式 - 恢复事件订阅
                        LogManager.Info("起点选择完成，恢复正常事件订阅状态");
                        CleanupAutoPathEventSubscriptions();
                        _pathPlanningManager?.EnableMouseHandling(); // 恢复PathPlanningManager的鼠标处理
                        _pathPlanningManager?.StopClickTool();
                    }, "停止起点选择工具");
                }
                else if (IsSelectingEndPoint)
                {
                    SetAutoPathEndPoint(point3D);
                    await SafeExecuteAsync(() =>
                    {
                        // 退出自动路径规划模式 - 恢复事件订阅
                        LogManager.Info("终点选择完成，恢复正常事件订阅状态");
                        CleanupAutoPathEventSubscriptions();
                        _pathPlanningManager?.EnableMouseHandling(); // 恢复PathPlanningManager的鼠标处理
                        _pathPlanningManager?.StopClickTool();
                    }, "停止终点选择工具");
                }
                else
                {
                    CleanupAutoPathEventSubscriptions();
                    _pathPlanningManager?.EnableMouseHandling(); // 恢复PathPlanningManager的鼠标处理
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"[自动路径事件] 处理点击事件异常: {ex.Message}");
                UpdateMainStatus($"获取点击位置失败: {ex.Message}");

                IsSelectingStartPoint = false;
                IsSelectingEndPoint = false;

                // 异常情况下也要清理事件订阅并恢复状态
                try
                {
                    CleanupAutoPathEventSubscriptions();
                    _pathPlanningManager?.EnableMouseHandling(); // 恢复PathPlanningManager的鼠标处理
                    _pathPlanningManager?.StopClickTool();
                }
                catch (Exception cleanupEx)
                {
                    LogManager.Error($"[自动路径事件] 清理异常: {cleanupEx.Message}");
                }
            }
        }

        /// <summary>
        /// 设置自动路径规划的起点
        /// </summary>
        public async void SetAutoPathStartPoint(Point3D point)
        {
            await SafeExecuteAsync(() =>
            {
                // 直接设置新的起点（清理逻辑已在ExecuteSelectStartPointAsync中处理）
                _startPoint3D = point;
                _hasStartPoint = true;
                AutoPathStartPoint = $"({point.X:F2}, {point.Y:F2}, {point.Z:F2})";
                IsSelectingStartPoint = false;

                // 通知Can Execute属性更改
                OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                OnPropertyChanged(nameof(CanExecuteNewPath));

                // 渲染新的起点标记
                if (PathPointRenderPlugin.Instance != null)
                {
                    // 创建临时路径只包含起点
                    _autoPathStartPointRoute = new PathRoute("AutoPathStartPoint")
                    {
                        Description = "自动路径规划起点"
                    };
                    var startPathPoint = new PathPoint
                    {
                        Name = "起点",
                        Position = point,
                        Type = PathPointType.StartPoint
                    };
                    _autoPathStartPointRoute.AddPoint(startPathPoint);

                    // 使用新的只渲染点的API，不绘制连线
                    PathPointRenderPlugin.Instance.RenderPointOnly(_autoPathStartPointRoute);
                    LogManager.Info($"起点路径已创建，ID: {_autoPathStartPointRoute.Id}");
                }

                if (_hasEndPoint)
                {
                    UpdateMainStatus("起点和终点已设置，可以开始路径规划");
                }
                else
                {
                    UpdateMainStatus("起点已设置，请选择终点");
                }

                LogManager.Info($"起点已设置: ({point.X:F2}, {point.Y:F2}, {point.Z:F2})");
            }, "设置起点");
        }

        /// <summary>
        /// 设置自动路径规划的终点
        /// </summary>
        public async void SetAutoPathEndPoint(Point3D point)
        {
            await SafeExecuteAsync(() =>
            {
                // 直接设置新的终点（清理逻辑已在ExecuteSelectEndPointAsync中处理）
                _endPoint3D = point;
                _hasEndPoint = true;
                AutoPathEndPoint = $"({point.X:F2}, {point.Y:F2}, {point.Z:F2})";
                IsSelectingEndPoint = false;

                // 通知Can Execute属性更改
                OnPropertyChanged(nameof(CanExecuteAutoPlanPath));
                OnPropertyChanged(nameof(CanExecuteNewPath));

                // 渲染新的终点标记
                if (PathPointRenderPlugin.Instance != null)
                {
                    // 创建临时路径只包含终点
                    _autoPathEndPointRoute = new PathRoute("AutoPathEndPoint")
                    {
                        Description = "自动路径规划终点"
                    };
                    var endPathPoint = new PathPoint
                    {
                        Name = "终点",
                        Position = point,
                        Type = PathPointType.EndPoint
                    };
                    _autoPathEndPointRoute.AddPoint(endPathPoint);

                    // 使用新的只渲染点的API，不绘制连线
                    PathPointRenderPlugin.Instance.RenderPointOnly(_autoPathEndPointRoute);
                    LogManager.Info($"终点路径已创建，ID: {_autoPathEndPointRoute.Id}");
                }

                if (_hasStartPoint)
                {
                    UpdateMainStatus("起点和终点已设置，可以开始路径规划");
                }
                else
                {
                    UpdateMainStatus("终点已设置，请选择起点");
                }

                LogManager.Info($"终点已设置: ({point.X:F2}, {point.Y:F2}, {point.Z:F2})");
            }, "设置终点");
        }

        #endregion

        #region 物体参数同步

        /// <summary>
        /// 同步物体参数到渲染插件
        /// </summary>
        private void SyncObjectParametersToRenderPlugin()
        {
            try
            {
                if (PathPointRenderPlugin.Instance != null)
                {
                    // 检查检测动画页签是否选择了物体或使用了虚拟物体
                    // 如果有，使用动画页签的物体参数来更新通行空间（而不是跳过）
                    var animationVm = AnimationControlViewModel.Instance;
                    if (animationVm != null && animationVm.HasSelectedAnimatedObject)
                    {
                        // 动画页签已选择物体，使用动画页签的物体尺寸和当前路径的类型
                        LogManager.Debug("[物体参数同步] 检测动画页签已选择动画对象，使用动画页签的物体尺寸");
                        SyncAnimationViewObjectParameters(animationVm);
                        return;
                    }

                    // 将米单位转换为模型单位（SetPassageSpaceParameters需要模型单位）
                    var metersToUnits = UnitsConverter.GetMetersToUnitsConversionFactor();
                    double objectLengthModel = ObjectLength * metersToUnits;
                    double objectWidthModel = ObjectWidth * metersToUnits;
                    double objectHeightModel = ObjectHeight * metersToUnits;
                    double safetyMarginModel = SafetyMargin * metersToUnits;

                    // 根据路径类型计算通行空间尺寸
                    double passageAcrossPath, passageNormalToPath, passageAlongPath;
                    PathType pathType = SelectedPathRoute?.PathType ?? PathType.Ground;

                    if (pathType == PathType.Rail)
                    {
                        // 空轨路径：物体水平悬挂，垂直于路径的截面包含物体的宽度和高度
                        passageAcrossPath = objectWidthModel + 2 * safetyMarginModel; // Y方向（宽度）+ 2*间隙（垂直于路径方向）
                        passageNormalToPath = objectHeightModel + 2 * safetyMarginModel; // Z方向（高度）+ 2*间隙（法线方向）
                        passageAlongPath = objectLengthModel; // X方向（长度）（沿路径方向）
                    }
                    else if (pathType == PathType.Hoisting)
                    {
                        // 吊装路径：物体垂直悬挂，垂直于路径的截面包含物体的长度和宽度
                        passageAcrossPath = objectWidthModel + 2 * safetyMarginModel; // Y方向（宽度）+ 2*间隙（垂直于路径方向）
                        passageNormalToPath = objectLengthModel + 2 * safetyMarginModel; // X方向（长度）+ 2*间隙（法线方向）
                        passageAlongPath = objectHeightModel; // Z方向（高度）（沿路径方向）
                    }
                    else // Ground
                    {
                        // 地面路径：高度只有上方加间隙
                        passageAcrossPath = objectWidthModel + 2 * safetyMarginModel; // Y方向（宽度）+ 2*间隙（垂直于路径方向）
                        passageNormalToPath = objectHeightModel + safetyMarginModel; // Z方向（高度）+ 间隙（法线方向，只有上方）
                        passageAlongPath = objectLengthModel; // X方向（长度）（沿路径方向）
                    }

                    // 设置通行空间参数到渲染插件
                    // passageNormalToPathVertical: 垂直段的高度（物体长度 + 2×安全间隙）
                    // passageNormalToPathHorizontal: 水平段的高度（物体高度 + 2×安全间隙）
                    double passageNormalToPathVertical = objectLengthModel + 2 * safetyMarginModel;
                    double passageNormalToPathHorizontal = objectHeightModel + 2 * safetyMarginModel;
                    PathPointRenderPlugin.Instance.SetPassageSpaceParameters(
                        passageAcrossPath,
                        passageNormalToPath,
                        passageAlongPath,
                        passageNormalToPathVertical,
                        passageNormalToPathHorizontal);
                    LogManager.Debug($"[物体参数同步] 已设置通行空间参数: 垂直路径={passageAcrossPath / metersToUnits:F2}m, 法线={passageNormalToPath / metersToUnits:F2}m, 沿路径={passageAlongPath / metersToUnits:F2}m, 间隙={SafetyMargin:F2}m");
                }
                else
                {
                    LogManager.Warning("[物体参数同步] PathPointRenderPlugin实例为空，无法同步物体参数");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"[物体参数同步] 同步物体参数失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 使用动画页签的物体参数同步到渲染插件
        /// </summary>
        private void SyncAnimationViewObjectParameters(AnimationControlViewModel animationVm)
        {
            try
            {
                // 获取当前路径类型（使用路径编辑页签的当前选择）
                PathType pathType = SelectedPathRoute?.PathType ?? PathType.Ground;
                
                // 获取单位转换因子
                var metersToUnits = UnitsConverter.GetMetersToUnitsConversionFactor();
                double safetyMarginModel = SafetyMargin * metersToUnits;

                double objectLengthModel, objectWidthModel, objectHeightModel;

                if (animationVm.UseVirtualObject)
                {
                    // 使用虚拟物体尺寸
                    objectLengthModel = animationVm.VirtualObjectLengthInMeters * metersToUnits;
                    objectWidthModel = animationVm.VirtualObjectWidthInMeters * metersToUnits;
                    objectHeightModel = animationVm.VirtualObjectHeightInMeters * metersToUnits;
                    LogManager.Debug($"[物体参数同步] 使用虚拟物体尺寸: {animationVm.VirtualObjectLengthInMeters:F2}m x {animationVm.VirtualObjectWidthInMeters:F2}m x {animationVm.VirtualObjectHeightInMeters:F2}m");
                }
                else if (animationVm.SelectedAnimatedObject != null)
                {
                    var animationManager = NavisworksTransport.Core.Animation.PathAnimationManager.GetInstance();
                    if ((pathType == PathType.Ground || pathType == PathType.Hoisting) &&
                        animationManager != null &&
                        animationManager.TryGetCurrentRouteRealObjectPlanarProjectedExtents(
                            out double resolvedPlanarForward,
                            out double resolvedPlanarSide,
                            out double resolvedPlanarUp))
                    {
                        objectLengthModel = resolvedPlanarForward;
                        objectWidthModel = resolvedPlanarSide;
                        objectHeightModel = resolvedPlanarUp;
                        LogManager.Debug(
                            $"[物体参数同步] 使用真实物体平面路径最终姿态尺寸: " +
                            $"沿路径={resolvedPlanarForward / metersToUnits:F2}m, " +
                            $"垂直路径={resolvedPlanarSide / metersToUnits:F2}m, " +
                            $"法线={resolvedPlanarUp / metersToUnits:F2}m");
                    }
                    else if (pathType == PathType.Rail &&
                             animationManager != null &&
                             animationManager.TryGetCurrentRouteRealObjectRailProjectedExtents(
                                 out double resolvedRailForward,
                                 out double resolvedRailSide,
                                 out double resolvedRailUp))
                    {
                        objectLengthModel = resolvedRailForward;
                        objectWidthModel = resolvedRailSide;
                        objectHeightModel = resolvedRailUp;
                        LogManager.Debug(
                            $"[物体参数同步] 使用真实物体 Rail 最终姿态尺寸: " +
                            $"沿路径={resolvedRailForward / metersToUnits:F2}m, " +
                            $"垂直路径={resolvedRailSide / metersToUnits:F2}m, " +
                            $"法线={resolvedRailUp / metersToUnits:F2}m");
                    }
                    else
                    {
                        // 回退：使用选择物体时保存的原始尺寸（米）
                        objectLengthModel = animationVm.ObjectOriginalLength * metersToUnits;
                        objectWidthModel = animationVm.ObjectOriginalWidth * metersToUnits;
                        objectHeightModel = animationVm.ObjectOriginalHeight * metersToUnits;
                        LogManager.Debug(
                            $"[物体参数同步] 回退使用选择物体保存的原始尺寸: " +
                            $"{animationVm.ObjectOriginalLength:F2}m x {animationVm.ObjectOriginalWidth:F2}m x {animationVm.ObjectOriginalHeight:F2}m");
                    }
                }
                else
                {
                    // 没有物体，使用默认参数
                    LogManager.Warning("[物体参数同步] 动画页签已选择物体但实际无物体，使用默认参数");
                    objectLengthModel = ObjectLength * metersToUnits;
                    objectWidthModel = ObjectWidth * metersToUnits;
                    objectHeightModel = ObjectHeight * metersToUnits;
                }

                // 根据路径类型计算通行空间尺寸
                double passageAcrossPath, passageNormalToPath, passageAlongPath;

                if (pathType == PathType.Rail)
                {
                    passageAcrossPath = objectWidthModel + 2 * safetyMarginModel;
                    passageNormalToPath = objectHeightModel + 2 * safetyMarginModel;
                    passageAlongPath = objectLengthModel;
                }
                else if (pathType == PathType.Hoisting)
                {
                    passageAcrossPath = objectWidthModel + 2 * safetyMarginModel;
                    passageNormalToPath = objectLengthModel + 2 * safetyMarginModel;
                    passageAlongPath = objectHeightModel;
                }
                else // Ground
                {
                    passageAcrossPath = objectWidthModel + 2 * safetyMarginModel;
                    passageNormalToPath = objectHeightModel + safetyMarginModel;
                    passageAlongPath = objectLengthModel;
                }

                // 设置通行空间参数到渲染插件
                double passageNormalToPathVertical = objectLengthModel + 2 * safetyMarginModel;
                double passageNormalToPathHorizontal = objectHeightModel + 2 * safetyMarginModel;
                PathPointRenderPlugin.Instance.SetPassageSpaceParameters(
                    passageAcrossPath,
                    passageNormalToPath,
                    passageAlongPath,
                    passageNormalToPathVertical,
                    passageNormalToPathHorizontal);
                LogManager.Debug($"[物体参数同步] 已使用动画页签物体参数设置通行空间: 类型={pathType}, 沿路径={passageAlongPath / metersToUnits:F2}m, 垂直路径={passageAcrossPath / metersToUnits:F2}m");
            }
            catch (Exception ex)
            {
                LogManager.Error($"[物体参数同步] 同步动画页签物体参数失败: {ex.Message}", ex);
            }
        }

        #endregion

        #region 辅助方法

        /// <summary>
        /// 安全执行异步操作
        /// </summary>
        private async Task SafeExecuteAsync(Func<Task> action, string operationName = "未知操作")
        {
            try
            {
                await action();
            }
            catch (Exception ex)
            {
                LogManager.Error($"{operationName}发生异常: {ex.Message}", ex);
                UpdateMainStatus($"{operationName}失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 网格可视化设置变更事件处理
        /// </summary>
        private void OnGridVisualizationChanged()
        {
            try
            {
                LogManager.Info($"网格可视化设置已更改: 通行={ShowWalkableGrid}, 障碍物={ShowObstacleGrid}, 未知={ShowUnknownGrid}, 门={ShowDoorGrid}");

                // 通知路径规划管理器更新网格可视化
                if (_pathPlanningManager != null)
                {
                    _pathPlanningManager.UpdateGridVisualizationSettings(
                        showWalkable: ShowWalkableGrid,
                        showObstacle: ShowObstacleGrid,
                        showUnknown: ShowUnknownGrid,
                        showDoor: ShowDoorGrid);

                    UpdateMainStatus("网格可视化设置已更新");
                }
                else
                {
                    LogManager.Warning("无法获取路径规划管理器，网格可视化设置可能不会立即生效");
                    UpdateMainStatus("网格可视化设置已保存");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"应用网格可视化设置失败: {ex.Message}", ex);
                UpdateMainStatus("网格可视化设置应用失败");
            }
        }

        /// <summary>
        /// 网格点类型变更事件处理
        /// </summary>
        private void OnGridPointTypeChanged()
        {
            try
            {
                LogManager.Info($"网格点类型已更改: {GridPointType}");

                // 通知路径点渲染插件更新网格点类型
                var renderPlugin = PathPointRenderPlugin.Instance;
                if (renderPlugin != null)
                {
                    renderPlugin.GridPointType = GridPointType;
                    UpdateMainStatus("网格点类型已更新");
                }
                else
                {
                    LogManager.Warning("无法获取PathPointRenderPlugin实例，网格点类型可能不会立即生效");
                    UpdateMainStatus("网格点类型已保存");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"应用网格点类型失败: {ex.Message}", ex);
                UpdateMainStatus("网格点类型应用失败");
            }
        }

        /// <summary>
        /// 根据路径类型自动设置可视化模式
        /// - 地面路径：控制点连线 + 路径线
        /// - 吊装和空轨：控制点连线 + 通行空间（不能使用路径线）
        /// </summary>
        private void UpdatePassageSpaceVisualizationForPathType(PathType pathType)
        {
            try
            {
                // 所有路径类型默认都打开控制点连线
                ShowControlVisualization = true;

                switch (pathType)
                {
                    case PathType.Rail:
                    case PathType.Hoisting:
                        // 空中路径：通行空间 + 控制点，不能使用路径线
                        ShowPathLines = false;
                        ShowObjectSpace = true;
                        LogManager.Debug($"[路径编辑] 路径类型={pathType}（空中路径），默认模式：控制点+通行空间");
                        break;

                    case PathType.Ground:
                        // 地面路径：路径线 + 控制点，不使用通行空间
                        ShowPathLines = true;
                        ShowObjectSpace = false;
                        LogManager.Debug($"[路径编辑] 路径类型={pathType}（地面路径），默认模式：控制点+路径线");
                        break;

                    default:
                        LogManager.Warning($"[路径编辑] 未知的路径类型: {pathType}");
                        return;
                }

                LogManager.Info($"[路径编辑] 已根据路径类型自动设置可视化模式：控制点={ShowControlVisualization}, 路径线={ShowPathLines}, 通行空间={ShowObjectSpace}");
                
                // 🔥 触发可视化状态变更事件，通知状态栏刷新按钮
                _pathPlanningManager?.RaiseVisualizationStateChanged();
            }
            catch (Exception ex)
            {
                LogManager.Error($"[路径编辑] 设置可视化模式失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 路径可视化模式变更事件处理
        /// </summary>
        private void OnPathVisualizationModeChanged()
        {
            try
            {
                var renderPlugin = PathPointRenderPlugin.Instance;
                if (renderPlugin != null)
                {
                    // 使用新的独立开关设置渲染插件
                    renderPlugin.ShowPathLines = ShowPathLines;
                    renderPlugin.ShowObjectSpace = ShowObjectSpace;

                    string modeName = "";
                    if (ShowPathLines && ShowObjectSpace)
                        modeName = "路径线 + 通行空间";
                    else if (ShowPathLines)
                        modeName = "路径线";
                    else if (ShowObjectSpace)
                        modeName = "通行空间";
                    else
                        modeName = "无路径可视化";

                    // 🔥 触发视图刷新
                    if (NavisApplication.ActiveDocument?.ActiveView != null)
                    {
                        NavisApplication.ActiveDocument.ActiveView.RequestDelayedRedraw(ViewRedrawRequests.Render);
                    }

                    LogManager.Info($"路径可视化模式已更改: {modeName}");
                    UpdateMainStatus($"路径可视化: {modeName}");
                }
                else
                {
                    LogManager.Warning("无法获取PathPointRenderPlugin实例");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"应用路径可视化模式失败: {ex.Message}", ex);
                UpdateMainStatus("路径可视化模式更新失败");
            }
        }

        /// <summary>
        /// 控制点可视化变更事件处理
        /// </summary>
        private void OnControlVisualizationChanged()
        {
            try
            {
                var renderPlugin = PathPointRenderPlugin.Instance;
                if (renderPlugin != null)
                {
                    // 更新所有路径的 ShowControlVisualization 属性
                    lock (typeof(PathPointRenderPlugin))
                    {
                        var allVisualizations = renderPlugin.GetAllPathVisualizations();
                        foreach (var visualization in allVisualizations)
                        {
                            visualization.ShowControlVisualization = ShowControlVisualization;
                        }
                    }

                    // 触发视图刷新
                    if (NavisApplication.ActiveDocument?.ActiveView != null)
                    {
                        NavisApplication.ActiveDocument.ActiveView.RequestDelayedRedraw(ViewRedrawRequests.Render);
                    }

                    LogManager.Info($"控制点可视化已更改: {(ShowControlVisualization ? "显示" : "隐藏")}");
                    UpdateMainStatus("控制点可视化已更新");
                }
                else
                {
                    LogManager.Warning("无法获取PathPointRenderPlugin实例");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"应用控制点可视化设置失败: {ex.Message}", ex);
                UpdateMainStatus("控制点可视化设置失败");
            }
        }

        /// <summary>
        /// 清理自动路径相关的事件订阅
        /// </summary>
        private void CleanupAutoPathEventSubscriptions()
        {
            try
            {
                // 简单安全地移除事件订阅
                // 由于C#事件处理机制，多次取消订阅同一个处理程序是安全的
                // 即使处理程序未订阅，取消操作也不会抛出异常
                PathClickToolPlugin.MouseClicked -= OnAutoPathMouseClicked;
            }
            catch (Exception ex)
            {
                LogManager.Error($"[事件清理] 清理自动路径事件订阅失败: {ex.Message}", ex);
                // 记录异常但不抛出，避免影响主流程
            }
        }

        /// <summary>
        /// 清理临时的自动路径起点和终点标记
        /// </summary>
        private void ClearTemporaryAutoPathMarkers()
        {
            try
            {
                if (PathPointRenderPlugin.Instance != null)
                {
                    // 清除临时的起点标记（使用正确的路径ID）
                    if (_autoPathStartPointRoute != null)
                    {
                        PathPointRenderPlugin.Instance.RemovePath(_autoPathStartPointRoute.Id);
                        _autoPathStartPointRoute = null;
                    }

                    // 清除临时的终点标记（使用正确的路径ID）
                    if (_autoPathEndPointRoute != null)
                    {
                        PathPointRenderPlugin.Instance.RemovePath(_autoPathEndPointRoute.Id);
                        _autoPathEndPointRoute = null;
                    }

                }
                else
                {
                    LogManager.Warning("[临时标记清理] PathPointRenderPlugin实例为null，无法清理标记");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"[临时标记清理] 清理临时标记失败: {ex.Message}");
            }
        }

        #endregion

        #region PathPlanningManager事件处理

        /// <summary>
        /// 订阅PathPlanningManager事件
        /// </summary>
        private void SubscribeToPathPlanningManager()
        {
            if (_pathPlanningManager == null)
            {
                LogManager.Debug("PathPlanningManager尚未设置，跳过事件订阅");
                return;
            }

            try
            {
                // 订阅路径点操作事件（用于手工路径编辑）
                _pathPlanningManager.PathPointOperation += OnPathPointOperation;

                // 订阅路径点列表更新事件
                _pathPlanningManager.PathPointsListUpdated += OnPathPointsListUpdated;

                // 订阅当前路径变更事件
                _pathPlanningManager.CurrentRouteChanged += OnCurrentRouteChanged;

                // 订阅编辑状态变更事件
                _pathPlanningManager.EditStateChanged += OnEditStateChanged;

                // 订阅路径生成事件（用于处理自动路径）
                _pathPlanningManager.RouteGenerated += OnRouteGenerated;

                // 订阅路径加载完成事件（用于处理数据库加载的路径）
                _pathPlanningManager.RoutesLoaded += OnRoutesLoaded;

                // 添加错误事件订阅 - 用于处理自动路径规划失败等错误
                _pathPlanningManager.ErrorOccurred += OnPathPlanningError;

                LogManager.Debug("PathEditingViewModel已成功订阅PathPlanningManager事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"*** 订阅PathPlanningManager事件失败: {ex.Message} ***", ex);
            }
        }

        /// <summary>
        /// 取消订阅PathPlanningManager事件
        /// </summary>
        private void UnsubscribeFromPathPlanningManager()
        {
            if (_pathPlanningManager == null) return;

            try
            {
                _pathPlanningManager.PathPointOperation -= OnPathPointOperation;
                _pathPlanningManager.PathPointsListUpdated -= OnPathPointsListUpdated;
                _pathPlanningManager.CurrentRouteChanged -= OnCurrentRouteChanged;
                _pathPlanningManager.EditStateChanged -= OnEditStateChanged;
                _pathPlanningManager.RouteGenerated -= OnRouteGenerated;
                _pathPlanningManager.RoutesLoaded -= OnRoutesLoaded;
                _pathPlanningManager.ErrorOccurred -= OnPathPlanningError;

                LogManager.Info("PathEditingViewModel已取消订阅PathPlanningManager事件，包括ErrorOccurred");
            }
            catch (Exception ex)
            {
                LogManager.Error($"取消订阅PathPlanningManager事件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 处理路径点操作事件（手工路径编辑的核心）
        /// </summary>
        private async void OnPathPointOperation(object sender, PathPointOperationEventArgs e)
        {
            if (e == null || e.PathPoint == null) return;

            try
            {
                await SafeExecuteAsync(() =>
                {
                    LogManager.Info($"PathEditingViewModel收到路径点操作事件: {e.OperationType}, 点: {e.PathPoint.Name}");

                    // 只处理手动编辑的路径点，跳过自动路径点
                    // 自动路径通过RouteGenerated事件处理
                    if (e.PathPoint.Name.Contains("自动"))
                    {
                        LogManager.Info($"跳过自动路径点，将通过RouteGenerated事件处理: {e.PathPoint.Name}");
                        return;
                    }

                    // 注意：不在这里直接添加/移除单个路径点到UI
                    // 因为PathPointsListUpdated事件会处理完整的路径同步
                    // 这里只做状态更新和选择管理

                    if (e.OperationType == PathPointOperationType.Added)
                    {
                        // 确保对应的路径在UI中存在并选中
                        var pathViewModel = PathRoutes.FirstOrDefault(p => p.Name == e.Route.Name);
                        if (pathViewModel != null)
                        {
                            // 设置为选中路径
                            SelectedPathRoute = pathViewModel;
                        }

                        UpdateMainStatus($"已添加路径点: {e.PathPoint.Name} 到 {e.Route.Name}");
                        LogManager.Info($"路径点操作完成: {e.PathPoint.Name} 已添加到路径 {e.Route.Name}");
                    }
                    else if (e.OperationType == PathPointOperationType.Removed)
                    {
                        UpdateMainStatus($"已移除路径点: {e.PathPoint.Name} 从 {e.Route.Name}");
                        LogManager.Info($"路径点操作完成: {e.PathPoint.Name} 已从路径 {e.Route.Name} 移除");
                    }
                }, "处理路径点操作事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"处理路径点操作事件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 处理路径点列表更新事件
        /// </summary>
        private async void OnPathPointsListUpdated(object sender, PathPointsListUpdatedEventArgs e)
        {
            if (e?.Route == null) return;

            try
            {
                await SafeExecuteAsync(() =>
                {
                    LogManager.Info($"路径点列表更新: {e.Route.Name}, 原因: {e.UpdateReason}");

                    // 刷新对应路径的显示
                    var pathViewModel = PathRoutes.FirstOrDefault(p => p.Name == e.Route.Name);
                    if (pathViewModel != null)
                    {
                        bool updated = SyncPathViewModelFromCoreRoute(pathViewModel, e.Route, preserveSelection: true);
                        if (!updated)
                        {
                            LogManager.Info($"路径点数据无变化({pathViewModel.Points.Count})，跳过更新");
                            return;
                        }

                        LogManager.Info($"已更新路径点列表，当前点数: {pathViewModel.Points.Count}");

                        // 更新真实路径可视化
                        UpdatePathVisualization();
                    }
                    else
                    {
                        LogManager.Warning($"未找到对应的PathViewModel: {e.Route.Name}");
                    }
                }, "处理路径点列表更新事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"处理路径点列表更新事件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 处理当前路径变更事件
        /// </summary>
        private async void OnCurrentRouteChanged(object sender, CurrentRouteChangedEventArgs e)
        {
            try
            {
                await SafeExecuteAsync(() =>
                {
                    LogManager.Info($"当前路径变更: {e.PreviousRoute?.Name} -> {e.NewRoute?.Name}");

                    if (e.NewRoute != null)
                    {
                        // 查找并选中对应的路径ViewModel
                        var pathViewModel = PathRoutes.FirstOrDefault(p => p.Name == e.NewRoute.Name);
                        if (pathViewModel != null)
                        {
                            bool synced = SyncPathViewModelFromCoreRoute(pathViewModel, e.NewRoute, preserveSelection: true);
                            if (synced)
                            {
                                LogManager.Info($"当前路径切换时已同步路径点列表: {e.NewRoute.Name}, 点数: {pathViewModel.Points.Count}");
                            }

                            // 只在真的不同时才设置，避免重复触发
                            if (SelectedPathRoute != pathViewModel)
                            {
                                SelectedPathRoute = pathViewModel;
                                LogManager.Info($"UI已同步选择路径: {e.NewRoute.Name}");
                            }
                        }
                        else
                        {
                            LogManager.Warning($"OnCurrentRouteChanged: UI中未找到路径 {e.NewRoute.Name}，可能UI还未刷新");
                        }
                    }
                    else
                    {
                        // 当前路径被设为null，清除UI选择
                        if (SelectedPathRoute != null)
                        {
                            SelectedPathRoute = null;
                            LogManager.Info("UI已清除路径选择");
                        }
                    }
                }, "处理当前路径变更事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"处理当前路径变更事件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 处理编辑状态变更事件
        /// </summary>
        private async void OnEditStateChanged(object sender, PathEditStateChangedEventArgs e)
        {
            try
            {
                await SafeExecuteAsync(() =>
                {
                    LogManager.Info($"路径编辑状态变更: {e.PreviousState} -> {e.NewState}");

                    // 修复：包含 AddingPoints 和 EditingPoint 状态
                    IsPathEditMode = (e.NewState == PathEditState.Creating ||
                                    e.NewState == PathEditState.Editing ||
                                    e.NewState == PathEditState.AddingPoints ||
                                    e.NewState == PathEditState.EditingPoint);

                    LogManager.Info($"[UI状态更新] IsPathEditMode 设为: {IsPathEditMode}");

                    // 更新状态提示
                    switch (e.NewState)
                    {
                        case PathEditState.Creating:
                            UpdateMainStatus($"正在新建路径: {e.EditingRoute?.Name} - 请在3D视图中点击设置路径点");
                            break;
                        case PathEditState.Editing:
                            UpdateMainStatus($"正在编辑路径: {e.EditingRoute?.Name} - 请在3D视图中点击设置路径点");
                            break;
                        case PathEditState.AddingPoints:
                            UpdateMainStatus($"正在添加路径点到: {e.EditingRoute?.Name} - 请在3D视图中点击设置路径点");
                            break;
                        case PathEditState.EditingPoint:
                            UpdateMainStatus($"正在修改路径点: {e.EditingRoute?.Name} - 请在3D视图中点击新位置，然后点击'结束'确认");
                            break;
                        case PathEditState.Viewing:
                            // 如果当前状态包含路径规划完成信息（包括完成度百分比），则保留不覆盖
                            var currentStatus = _mainViewModel?.StatusText ?? "";
                            if (!currentStatus.Contains("路径规划完成") && !currentStatus.Contains("路径规划部分完成") &&
                                !currentStatus.Contains("✅") && !currentStatus.Contains("🔶"))
                            {
                                UpdateMainStatus("路径编辑已完成");
                            }
                            break;
                        default:
                            UpdateMainStatus("就绪");
                            break;
                    }

                    // 通知命令状态更新
                    OnPropertyChanged(nameof(CanExecuteNewPath));
                    OnPropertyChanged(nameof(CanExecuteStartEdit));
                    OnPropertyChanged(nameof(CanExecuteEndEdit));
                    OnPropertyChanged(nameof(CanExecuteModifyPoint));
                    OnPropertyChanged(nameof(CanExecuteCancelModifyPoint));

                    LogManager.Info($"[UI状态更新] 按钮状态已通知更新 - CanExecuteStartEdit: {CanExecuteStartEdit}, CanExecuteEndEdit: {CanExecuteEndEdit}, CanExecuteModifyPoint: {CanExecuteModifyPoint}, CanExecuteCancelModifyPoint: {CanExecuteCancelModifyPoint}");
                }, "处理编辑状态变更事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"处理编辑状态变更事件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 处理路径生成事件（用于自动路径）
        /// </summary>
        private async void OnRouteGenerated(object sender, RouteGeneratedEventArgs e)
        {
            // 添加调试日志确认事件是否被调用
            LogManager.Info($"*** OnRouteGenerated被调用！Sender: {sender?.GetType().Name}, Route: {e?.Route?.Name}, Method: {e?.GenerationMethod}, GridSize: {e?.GridSize} ***");

            if (e?.Route == null)
            {
                LogManager.Warning("*** OnRouteGenerated: RouteGeneratedEventArgs或Route为null，退出处理 ***");
                return;
            }

            try
            {
                await SafeExecuteAsync(() =>
                {
                    LogManager.Info($"PathEditingViewModel收到路径生成事件: {e.Route.Name}, 生成方式: {e.GenerationMethod}");

                    // 处理自动路径生成
                    if (e.GenerationMethod == RouteGenerationMethod.AutoPlanning)
                    {
                        LogManager.Info($"*** 开始处理自动路径生成: {e.Route.Name} ***");

                        // 创建对应的 WPF ViewModel
                        var autoPathViewModel = new PathRouteViewModel(isFromDatabase: true)
                        {
                            Route = e.Route,
                            IsActive = true
                        };

                        // 设置时间信息
                        autoPathViewModel.SetTimeInfo(e.Route.CreatedTime, e.Route.LastModified);

                        // 使用统一的辅助方法创建路径点
                        var pathPoints = CreatePathPointViewModelsFromCoreRoute(e.Route);
                        foreach (var point in pathPoints)
                        {
                            autoPathViewModel.Points.Add(point);
                        }

                        LogManager.Info($"*** 已创建PathRouteViewModel，包含 {autoPathViewModel.Points.Count} 个点 ***");

                        // 检查是否已存在同名路径，避免重复添加
                        var existingPath = PathRoutes.FirstOrDefault(p => p.Name == e.Route.Name);
                        if (existingPath == null)
                        {
                            // 添加到 UI 列表并选中
                            PathRoutes.Add(autoPathViewModel);
                            SelectedPathRoute = autoPathViewModel;

                            LogManager.Info($"*** 自动路径已添加到UI列表: {e.Route.Name}，当前PathRoutes.Count = {PathRoutes.Count} ***");
                        }
                        else
                        {
                            // 更新现有路径
                            existingPath.Points.Clear();
                            foreach (var wpfPoint in autoPathViewModel.Points)
                            {
                                existingPath.Points.Add(wpfPoint);
                            }
                            SelectedPathRoute = existingPath;

                            LogManager.Info($"*** 自动路径已更新UI列表: {e.Route.Name} ***");
                        }

                        // 构建包含网格信息和完成度的完整状态消息，使用事件参数中的网格大小信息
                        var gridInfo = e.GridSize > 0 ? $"网格{e.GridSize:F1}m" : "自动网格";
                        string statusMessage;

                        if (e.Route.IsComplete)
                        {
                            // 完全到达终点
                            statusMessage = $"✅ 自动路径规划完成: {e.Route.Name}，共 {e.Route.Points.Count} 个路径点，长度 {e.Route.TotalLength:F2}米";
                        }
                        else
                        {
                            // 部分到达终点
                            statusMessage = $"🔶 自动路径规划部分完成: {e.Route.Name}，共 {e.Route.Points.Count} 个路径点，长度 {e.Route.TotalLength:F2}米，(完成度: {e.Route.CompletionPercentage:F1}%)";
                        }

                        UpdateMainStatus(statusMessage);
                        LogManager.Info($"*** 状态已更新: {statusMessage} ***");
                    }
                    else if (e.GenerationMethod == RouteGenerationMethod.Manual)
                    {
                        LogManager.Info($"手工路径生成完成: {e.Route.Name}，开始刷新路径列表");
                        var existingPath = PathRoutes.FirstOrDefault(p => p.Name == e.Route.Name);
                        if (existingPath == null)
                        {
                            existingPath = new PathRouteViewModel(isFromDatabase: true)
                            {
                                Route = e.Route,
                                IsActive = true
                            };
                            PathRoutes.Add(existingPath);
                            LogManager.Info($"手工路径生成后补建UI路径壳: {e.Route.Name}");
                        }

                        SyncPathViewModelFromCoreRoute(existingPath, e.Route, preserveSelection: true);
                        SelectedPathRoute = existingPath;
                        LogManager.Info($"手工路径已同步并重新选中: {e.Route.Name}，点数: {existingPath.Points.Count}");

                        OnPropertyChanged(nameof(PathRoutes));
                        OnPropertyChanged(nameof(CanExecuteStartEdit));
                        OnPropertyChanged(nameof(CanExecuteEndEdit));
                    }
                    else if (e.GenerationMethod == RouteGenerationMethod.DatabaseLoad)
                    {
                        // 注意：DatabaseLoad现在由OnRoutesLoaded事件处理，这里不再处理
                        LogManager.Warning($"*** OnRouteGenerated收到DatabaseLoad方法，这不应该发生！应该由OnRoutesLoaded处理 ***");
                    }
                }, "处理路径生成事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"*** OnRouteGenerated异常: {ex.Message} ***", ex);
            }
        }

        /// <summary>
        /// 处理路径加载完成事件（用于数据库加载）
        /// </summary>
        private async void OnRoutesLoaded(object sender, RoutesLoadedEventArgs e)
        {
            LogManager.Info($"*** OnRoutesLoaded被调用！Sender: {sender?.GetType().Name}, RouteCount: {e?.RouteCount}, LoadSource: {e?.LoadSource} ***");

            if (e?.Routes == null)
            {
                LogManager.Warning("*** OnRoutesLoaded: RoutesLoadedEventArgs或Routes为null，退出处理 ***");
                return;
            }

            try
            {
                await SafeExecuteAsync(() =>
                {
                    LogManager.Info($"PathEditingViewModel收到路径加载完成事件: 加载了 {e.RouteCount} 条路径，来源: {e.LoadSource}");

                    // 处理从数据库加载的历史路径
                    foreach (var coreRoute in e.Routes)
                    {
                        // 创建对应的 WPF ViewModel
                        var dbPathViewModel = new PathRouteViewModel(isFromDatabase: true)
                        {
                            Route = coreRoute,
                            IsActive = false,  // 历史路径默认不激活
                            PathType = coreRoute.PathType
                        };

                        // 设置时间信息
                        dbPathViewModel.SetTimeInfo(coreRoute.CreatedTime, coreRoute.LastModified);

                        // 使用统一的辅助方法创建路径点
                        var pathPoints = CreatePathPointViewModelsFromCoreRoute(coreRoute);
                        foreach (var point in pathPoints)
                        {
                            dbPathViewModel.Points.Add(point);
                        }

                        // 检查是否已存在同名路径，避免重复添加
                        var existingPath = PathRoutes.FirstOrDefault(p => p.Name == coreRoute.Name);
                        if (existingPath == null)
                        {
                            // 添加到 UI 列表
                            PathRoutes.Add(dbPathViewModel);
                        }
                        else
                        {
                            LogManager.Debug($"*** 数据库路径已存在，跳过: {coreRoute.Name} ***");
                        }
                    }

                    // 更新状态消息
                    string statusMessage = $"✅ 已从{e.LoadSource}加载 {e.RouteCount} 条历史路径";
                    UpdateMainStatus(statusMessage);

                    // 自动提取并显示所有空轨模型的基准线
                    ExtractAndRenderRailBaselinePaths();
                }, "处理路径加载完成事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"*** OnRoutesLoaded异常: {ex.Message} ***", ex);
            }
        }

        /// <summary>
        /// 处理路径规划错误事件
        /// </summary>
        /// <summary>
        /// 处理路径规划错误事件
        /// </summary>
        /// <summary>
        /// 处理路径规划错误事件
        /// </summary>
        private async void OnPathPlanningError(object sender, PathPlanningErrorOccurredEventArgs e)
        {
            LogManager.Info($"*** OnPathPlanningError被调用！Sender: {sender?.GetType().Name}, Error: {e?.ErrorMessage}, Level: {e?.ErrorLevel} ***");

            try
            {
                await SafeExecuteAsync(async () =>
                {
                    // 根据错误级别决定日志记录方式
                    if (e.ErrorLevel == PathPlanningErrorLevel.Warning)
                    {
                        LogManager.Warning($"自动路径规划失败: {e.ErrorMessage}");
                    }
                    else
                    {
                        LogManager.Error($"自动路径规划失败: {e.ErrorMessage}");
                    }

                    // 使用UIStateManager确保UI更新在主线程执行
                    await _uiStateManager.ExecuteUIUpdateAsync(() =>
                    {
                        // 更新自动路径状态显示错误信息
                        UpdateMainStatus($"❌ 自动路径规划失败: {e.ErrorMessage}");
                        LogManager.Info($"*** 状态已更新为: ❌ 自动路径规划失败: {e.ErrorMessage} ***");
                    });

                }, "处理路径规划错误事件");
            }
            catch (Exception ex)
            {
                LogManager.Error($"*** OnPathPlanningError异常: {ex.Message} ***", ex);
            }
        }

        #endregion


        #region 清理资源

        /// <summary>
        /// 强制重新初始化ToolPlugin以确保获得鼠标焦点
        /// </summary>
        /// <param name="subscribeToEvents">是否订阅鼠标事件，新建路径需要true，自动路径选点需要false</param>
        /// <returns>初始化是否成功</returns>
        private bool ForceReinitializeToolPlugin(bool subscribeToEvents = false)
        {
            try
            {
                LogManager.Info($"开始强制重新初始化ToolPlugin以确保获得鼠标焦点，订阅事件: {subscribeToEvents}");

                // 使用PathPlanningManager的公共方法，避免反射调用
                if (_pathPlanningManager != null)
                {
                    bool result = _pathPlanningManager.ForceReinitializeToolPlugin(subscribeToEvents);
                    LogManager.Info($"ToolPlugin重新初始化结果（事件订阅: {subscribeToEvents}）: {result}");

                    if (result)
                    {
                        LogManager.Info("ToolPlugin重新初始化成功，已获得鼠标焦点");
                    }
                    else
                    {
                        LogManager.Error("ToolPlugin初始化失败");
                    }

                    return result;
                }
                else
                {
                    LogManager.Error("PathPlanningManager为null，无法重新初始化ToolPlugin");
                    return false;
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"重新初始化ToolPlugin失败: {ex.Message}", ex);
                return false;
            }
        }

        public void Cleanup()
        {
            try
            {
                LogManager.Info("开始清理PathEditingViewModel资源");

                // 取消配置变更事件订阅
                UnsubscribeFromConfigChanges();

                // 取消事件订阅
                UnsubscribeFromPathPlanningManager();

                // 完整清理自动路径规划相关的事件订阅
                try
                {
                    CleanupAutoPathEventSubscriptions();
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"清理自动路径事件订阅时发生异常: {ex.Message}");
                }

                try
                {
                    CleanupAssemblyReferenceSelection();
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"清理直线装配事件订阅时发生异常: {ex.Message}");
                }

                try
                {
                    CleanupAssemblyEndFaceSelection(clearVisuals: true);
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"清理端面三点分析事件订阅时发生异常: {ex.Message}");
                }

                try
                {
                    ClearAssemblyAnchorMarker();
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"清理直线装配对接点标记时发生异常: {ex.Message}");
                }

                try
                {
                    ClearAssemblyReferenceLine();
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"清理直线装配参考线时发生异常: {ex.Message}");
                }

                // 确保停止任何活动的点击工具
                try
                {
                    if (_pathPlanningManager != null)
                    {
                        _pathPlanningManager.StopClickTool();
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"停止点击工具时发生异常: {ex.Message}");
                }

                LogManager.Info("PathEditingViewModel资源清理完成");
            }
            catch (Exception ex)
            {
                LogManager.Error($"PathEditingViewModel清理失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 释放资源 (IDisposable implementation)
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 释放托管和非托管资源
        /// </summary>
        /// <param name="disposing">是否释放托管资源</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    try
                    {
                        // 调用现有的清理逻辑
                        Cleanup();
                        LogManager.Info("PathEditingViewModel已正确释放资源 (IDisposable)");
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"PathEditingViewModel释放资源时发生异常: {ex.Message}", ex);
                    }
                }
                _disposed = true;
            }
        }

        #endregion
    }

    /// <summary>
    /// 物体参数类 - 用于传递物体尺寸信息给路径规划算法
    /// </summary>
    public class ObjectParameters
    {
        public double Length { get; set; }
        public double Width { get; set; }
        public double Height { get; set; }
        public double SafetyMargin { get; set; }
    }
}