using System;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
using System.Windows.Input;
using NavisworksTransport.UI.WPF.ViewModels;
using NavisworksTransport.UI.WPF.Collections;
using NavisworksTransport.Core;
using NavisworksTransport.Utils;
using NavisworksTransport.Commands;

namespace NavisworksTransport.UI.WPF.ViewModels
{
    /// <summary>
    /// 系统管理ViewModel - 处理插件系统管理功能
    /// </summary>
    public class SystemManagementViewModel : ViewModelBase, IDisposable
    {
        #region 私有字段

        private readonly UIStateManager _uiStateManager;
        
        // 系统管理相关字段
        private bool _isAutoSaveEnabled = true;
        private bool _isDebugModeEnabled = false;
        
        // 网格可视化开关字段
        private bool _showWalkableGrid = false;
        private bool _showObstacleGrid = false;
        private bool _showUnknownGrid = false;
        private ObservableCollection<string> _logLevels;
        private string _selectedLogLevel = "Info";
        private string _pluginVersion = "v1.0";
        private string _navisworksVersion = "2026";
        private string _memoryUsage = "0 MB";
        private string _runningTime = "00:00:00";

        // 🔧 修复：添加定时器字段以便在清理时停止
        // 性能监控相关字段 (已改为Idle事件管理)
        private DateTime _lastPerformanceUpdate = DateTime.MinValue;
        private DateTime _startTime;
        
        // 🔧 修复：添加释放状态标志
        private bool _disposed = false;

        #endregion

        #region 公共属性

        /// <summary>
        /// 是否启用自动保存
        /// </summary>
        public bool IsAutoSaveEnabled
        {
            get => _isAutoSaveEnabled;
            set => SetProperty(ref _isAutoSaveEnabled, value);
        }

        /// <summary>
        /// 是否启用调试模式
        /// </summary>
        public bool IsDebugModeEnabled
        {
            get => _isDebugModeEnabled;
            set => SetProperty(ref _isDebugModeEnabled, value);
        }

        /// <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 ObservableCollection<string> LogLevels
        {
            get => _logLevels;
            set => SetProperty(ref _logLevels, value);
        }

        /// <summary>
        /// 选中的日志级别
        /// </summary>
        public string SelectedLogLevel
        {
            get => _selectedLogLevel;
            set => SetProperty(ref _selectedLogLevel, value);
        }



        /// <summary>
        /// 插件版本
        /// </summary>
        public string PluginVersion
        {
            get => _pluginVersion;
            set => SetProperty(ref _pluginVersion, value);
        }

        /// <summary>
        /// Navisworks版本
        /// </summary>
        public string NavisworksVersion
        {
            get => _navisworksVersion;
            set => SetProperty(ref _navisworksVersion, value);
        }




        /// <summary>
        /// 内存使用情况
        /// </summary>
        public string MemoryUsage
        {
            get => _memoryUsage;
            set => SetProperty(ref _memoryUsage, value);
        }

        /// <summary>
        /// 运行时间
        /// </summary>
        public string RunningTime
        {
            get => _runningTime;
            set => SetProperty(ref _runningTime, value);
        }


        #endregion

        #region 命令

        public ICommand ClearLogCommand { get; private set; }
        public ICommand ExportLogCommand { get; private set; }
        public ICommand ViewLogCommand { get; private set; }
        public ICommand OpenSettingsCommand { get; private set; }
        public ICommand ResetSettingsCommand { get; private set; }
        public ICommand ImportConfigCommand { get; private set; }
        public ICommand CheckUpdateCommand { get; private set; }
        public ICommand GeneratePerformanceReportCommand { get; private set; }
        public ICommand DiagnosticCommand { get; private set; }

        #endregion

        #region 构造函数

        public SystemManagementViewModel() : base()
        {
            try
            {
                // 获取UI状态管理器实例
                _uiStateManager = UIStateManager.Instance;
                
                // 验证关键组件是否正常初始化
                if (_uiStateManager == null)
                {
                    LogManager.Error("UIStateManager初始化失败");
                    throw new InvalidOperationException("UIStateManager初始化失败");
                }
                
                // 初始化线程安全的集合
                LogLevels = new ThreadSafeObservableCollection<string>();

                // 初始化命令
                InitializeCommands();

                // 初始化系统管理设置
                InitializeSystemManagementSettingsAsync();
                
                LogManager.Info("SystemManagementViewModel构造函数执行完成");
            }
            catch (Exception ex)
            {
                LogManager.Error($"SystemManagementViewModel构造函数异常: {ex.Message}", ex);
                
                // 在构造函数中尽量保证对象处于可用状态
                UpdateMainStatus("初始化失败，请检查日志");
                throw;
            }
        }

        /// <summary>
        /// 带主ViewModel参数的构造函数，支持统一状态栏
        /// </summary>
        /// <param name="mainViewModel">主ViewModel，用于统一状态栏</param>
        public SystemManagementViewModel(LogisticsControlViewModel mainViewModel) : base()
        {
            try
            {
                // 设置主ViewModel引用到基类
                SetMainViewModel(mainViewModel);
                
                // 获取UI状态管理器实例
                _uiStateManager = UIStateManager.Instance;
                
                // 验证关键组件是否正常初始化
                if (_uiStateManager == null)
                {
                    LogManager.Error("UIStateManager初始化失败");
                    throw new InvalidOperationException("UIStateManager初始化失败");
                }
                
                // 初始化线程安全的集合
                LogLevels = new ThreadSafeObservableCollection<string>();

                // 初始化命令
                InitializeCommands();

                // 初始化系统管理设置
                InitializeSystemManagementSettingsAsync();
                
                LogManager.Info("SystemManagementViewModel构造函数执行完成 - 支持统一状态栏");
            }
            catch (Exception ex)
            {
                LogManager.Error($"SystemManagementViewModel构造函数异常: {ex.Message}", ex);
                
                // 在构造函数中尽量保证对象处于可用状态
                UpdateMainStatus("初始化失败，请检查日志");
                throw;
            }
        }

        #endregion

        #region 初始化

        /// <summary>
        /// 初始化命令
        /// </summary>
        private void InitializeCommands()
        {
            try
            {
                // 系统管理命令
                ViewLogCommand = new RelayCommand(() => ExecuteViewLog());
                ClearLogCommand = new RelayCommand(() => ExecuteClearLog());
                ExportLogCommand = new RelayCommand(() => ExecuteExportLog());
                OpenSettingsCommand = new RelayCommand(() => ExecuteOpenSettings());
                ResetSettingsCommand = new RelayCommand(() => ExecuteResetSettings());
                ImportConfigCommand = new RelayCommand(() => ExecuteImportConfig());
                CheckUpdateCommand = new RelayCommand(() => ExecuteCheckUpdate());
                GeneratePerformanceReportCommand = new RelayCommand(() => ExecuteGeneratePerformanceReport());
                DiagnosticCommand = new RelayCommand(() => ExecuteDiagnostic());

                LogManager.Info("系统管理命令初始化完成");
            }
            catch (Exception ex)
            {
                LogManager.Error($"初始化命令失败: {ex.Message}", ex);
                throw;
            }
        }

        /// <summary>
        /// 网格可视化设置变更事件处理
        /// </summary>
        private void OnGridVisualizationChanged()
        {
            try
            {
                LogManager.Info($"网格可视化设置已更改: 通行={ShowWalkableGrid}, 障碍物={ShowObstacleGrid}, 未知={ShowUnknownGrid}");
                
                // 通知路径规划管理器更新网格可视化
                var pathPlanningManager = GetPathPlanningManager();
                if (pathPlanningManager != null)
                {
                    // 应用新的可视化设置
                    pathPlanningManager.UpdateGridVisualizationSettings(
                        showWalkable: ShowWalkableGrid,
                        showObstacle: ShowObstacleGrid, 
                        showUnknown: ShowUnknownGrid);
                    
                    UpdateMainStatus("网格可视化设置已更新");
                }
                else
                {
                    LogManager.Warning("无法获取路径规划管理器，网格可视化设置可能不会立即生效");
                    UpdateMainStatus("网格可视化设置已保存");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"应用网格可视化设置失败: {ex.Message}", ex);
                UpdateMainStatus("网格可视化设置应用失败");
            }
        }

        /// <summary>
        /// 获取路径规划管理器实例
        /// </summary>
        /// <returns>路径规划管理器或null</returns>
        private PathPlanningManager GetPathPlanningManager()
        {
            try
            {
                // 使用PathPlanningManager的静态方法获取活动实例
                var pathManager = PathPlanningManager.GetActivePathManager();
                if (pathManager != null)
                {
                    LogManager.Info("成功获取到活动的PathPlanningManager实例");
                    return pathManager;
                }
                else
                {
                    LogManager.Warning("当前没有活动的PathPlanningManager实例");
                    return null;
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"获取PathPlanningManager失败: {ex.Message}", ex);
                return null;
            }
        }

        /// <summary>
        /// 初始化系统管理设置
        /// </summary>
        private async Task InitializeSystemManagementSettingsAsync()
        {
            await SafeExecuteAsync(async () =>
            {
                await _uiStateManager.ExecuteUIUpdateAsync(() =>
                {
                    // 初始化日志级别
                    LogLevels.Clear();
                    var logLevels = new[] { "Debug", "Info", "Warning", "Error" };
                    foreach (var level in logLevels)
                    {
                        LogLevels.Add(level);
                    }
                    SelectedLogLevel = "Info";
                    
                    // 初始化系统信息
                    PluginVersion = "v1.0";
                    NavisworksVersion = "2026";
                    UpdateMainStatus("系统管理初始化完成");
                });
                
                // 启动性能监控
                StartPerformanceMonitoring();
                
                LogManager.Info("系统管理设置初始化完成");
            }, "初始化系统管理设置");
        }

        /// <summary>
        /// 启动性能监控 (已优化为Idle事件)
        /// </summary>
        private void StartPerformanceMonitoring()
        {
            // 如果已经释放，不启动监控
            if (_disposed)
            {
                LogManager.Info("SystemManagementViewModel已释放，跳过性能监控启动");
                return;
            }

            _startTime = DateTime.Now;
            _lastPerformanceUpdate = DateTime.MinValue;
            
            // 使用IdleEventManager注册性能监控任务，替代DispatcherTimer
            const string taskId = "SystemManagement_PerformanceMonitor";
            
            IdleEventManager.Instance.RegisterTask(
                taskId,
                UpdatePerformanceMetrics, // 要执行的操作
                30000, // 30秒间隔 (毫秒)
                5 // 中等优先级
            );
            
            LogManager.Info("SystemManagementViewModel性能监控已启动 (Idle事件模式)");
        }

        /// <summary>
        /// 更新性能指标 (Idle事件回调方法)
        /// </summary>
        private void UpdatePerformanceMetrics()
        {
            try
            {
                // 检查释放状态，避免在释放后继续更新UI
                if (_disposed)
                {
                    LogManager.Info("SystemManagementViewModel已释放，停止性能监控更新");
                    IdleEventManager.Instance.UnregisterTask("SystemManagement_PerformanceMonitor");
                    return;
                }

                // 更新内存使用
                var process = System.Diagnostics.Process.GetCurrentProcess();
                var memoryMB = process.WorkingSet64 / (1024 * 1024);
                MemoryUsage = $"{memoryMB} MB";
                
                // 更新运行时间
                var runTime = DateTime.Now - _startTime;
                RunningTime = $"{runTime.Hours:D2}:{runTime.Minutes:D2}:{runTime.Seconds:D2}";
                
                // 记录上次更新时间
                _lastPerformanceUpdate = DateTime.Now;
                
                LogManager.Debug($"性能指标已更新: 内存={MemoryUsage}, 运行时间={RunningTime}");
            }
            catch (Exception ex)
            {
                LogManager.Error($"性能监控更新失败: {ex.Message}");
                
                // 发生异常时停止监控，避免持续错误
                if (!_disposed)
                {
                    IdleEventManager.Instance.UnregisterTask("SystemManagement_PerformanceMonitor");
                }
            }
        }

        #endregion

        #region 命令实现


        /// <summary>
        /// 查看日志
        /// </summary>
        private void ExecuteViewLog()
        {
            SafeExecute(() =>
            {
                try
                {
                    // 创建并显示日志查看器对话框
                    var logViewerDialog = new NavisworksTransport.UI.WPF.Views.LogViewerDialog();
                    
                    // 尝试设置窗口所有者，使用更安全的方式
                    try
                    {
                        // 查找当前活动的主窗口
                        var mainWindow = System.Windows.Application.Current.MainWindow;
                        if (mainWindow != null && mainWindow.IsLoaded)
                        {
                            logViewerDialog.Owner = mainWindow;
                        }
                        else
                        {
                            // 如果主窗口不可用，查找当前活动的窗口
                            foreach (System.Windows.Window window in System.Windows.Application.Current.Windows)
                            {
                                if (window.IsActive && window.IsLoaded)
                                {
                                    logViewerDialog.Owner = window;
                                    break;
                                }
                            }
                        }
                    }
                    catch (Exception ownerEx)
                    {
                        // 如果设置Owner失败，记录警告但继续显示窗口
                        LogManager.Warning($"设置日志查看器Owner失败: {ownerEx.Message}");
                    }
                    
                    // 显示对话框（使用Show而不是ShowDialog以避免阻塞）
                    logViewerDialog.Show();
                    
                    UpdateMainStatus("日志查看器已打开");
                    LogManager.Info("通过系统管理打开日志查看器");
                }
                catch (Exception ex)
                {
                    UpdateMainStatus("打开日志查看器失败");
                    LogManager.Error($"打开日志查看器失败: {ex.Message}", ex);
                    
                    // 显示错误消息给用户
                    System.Windows.MessageBox.Show($"打开日志查看器失败: {ex.Message}", "错误", 
                                                  System.Windows.MessageBoxButton.OK, 
                                                  System.Windows.MessageBoxImage.Error);
                }
            }, "查看日志");
        }

        /// <summary>
        /// 清空日志
        /// </summary>
        private void ExecuteClearLog()
        {
            SafeExecute(() =>
            {
                try
                {
                    // 弹出确认对话框
                    var result = System.Windows.MessageBox.Show(
                        "确定要清空日志吗？此操作不可撤销。", 
                        "确认清空日志", 
                        System.Windows.MessageBoxButton.YesNo, 
                        System.Windows.MessageBoxImage.Question);
                    
                    if (result == System.Windows.MessageBoxResult.Yes)
                    {
                        // 调用LogManager清空日志
                        LogManager.ClearLog();
                        
                        UpdateMainStatus("日志已清空");
                        LogManager.Info("通过系统管理清空日志");
                        
                        // 显示成功消息
                        System.Windows.MessageBox.Show("日志已成功清空。", "操作完成", 
                                                      System.Windows.MessageBoxButton.OK, 
                                                      System.Windows.MessageBoxImage.Information);
                    }
                    else
                    {
                        UpdateMainStatus("取消清空日志");
                        LogManager.Info("用户取消清空日志操作");
                    }
                }
                catch (Exception ex)
                {
                    UpdateMainStatus("清空日志失败");
                    LogManager.Error($"清空日志失败: {ex.Message}", ex);
                    
                    // 显示错误消息给用户
                    System.Windows.MessageBox.Show($"清空日志失败: {ex.Message}", "错误", 
                                                  System.Windows.MessageBoxButton.OK, 
                                                  System.Windows.MessageBoxImage.Error);
                }
            }, "清空日志");
        }

        /// <summary>
        /// 导出日志
        /// </summary>
        private void ExecuteExportLog()
        {
            SafeExecute(() =>
            {
                try
                {
                    // 创建保存文件对话框
                    var saveFileDialog = new Microsoft.Win32.SaveFileDialog
                    {
                        Title = "导出日志文件",
                        Filter = "日志文件 (*.log)|*.log|文本文件 (*.txt)|*.txt|所有文件 (*.*)|*.*",
                        DefaultExt = "log",
                        FileName = $"NavisworksTransport_Log_{DateTime.Now:yyyyMMdd_HHmmss}.log"
                    };

                    if (saveFileDialog.ShowDialog() == true)
                    {
                        var logFilePath = LogManager.LogFilePath;
                        
                        if (System.IO.File.Exists(logFilePath))
                        {
                            // 从源日志文件复制到目标位置
                            System.IO.File.Copy(logFilePath, saveFileDialog.FileName, true);
                            
                            UpdateMainStatus($"日志已导出到: {System.IO.Path.GetFileName(saveFileDialog.FileName)}");
                            LogManager.Info($"日志已导出到: {saveFileDialog.FileName}");
                            
                            // 显示成功消息并询问是否打开文件夹
                            var result = System.Windows.MessageBox.Show(
                                $"日志已成功导出到:\n{saveFileDialog.FileName}\n\n是否打开文件所在文件夹？", 
                                "导出完成", 
                                System.Windows.MessageBoxButton.YesNo, 
                                System.Windows.MessageBoxImage.Information);
                            
                            if (result == System.Windows.MessageBoxResult.Yes)
                            {
                                // 打开文件所在文件夹并选中文件
                                System.Diagnostics.Process.Start("explorer.exe", $"/select,\"{saveFileDialog.FileName}\"");
                            }
                        }
                        else
                        {
                            // 如果日志文件不存在，创建一个空的日志文件
                            System.IO.File.WriteAllText(saveFileDialog.FileName, $"NavisworksTransport 日志文件\n导出时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}\n\n日志文件为空或不存在。\n");
                            
                            UpdateMainStatus("日志文件不存在，已创建空文件");
                            LogManager.Warning("日志文件不存在，已创建空的导出文件");
                            
                            System.Windows.MessageBox.Show("原始日志文件不存在，已创建空的导出文件。", "注意", 
                                                          System.Windows.MessageBoxButton.OK, 
                                                          System.Windows.MessageBoxImage.Warning);
                        }
                    }
                    else
                    {
                        UpdateMainStatus("取消导出日志");
                        LogManager.Info("用户取消导出日志操作");
                    }
                }
                catch (Exception ex)
                {
                    UpdateMainStatus("导出日志失败");
                    LogManager.Error($"导出日志失败: {ex.Message}", ex);
                    
                    // 显示错误消息给用户
                    System.Windows.MessageBox.Show($"导出日志失败: {ex.Message}", "错误", 
                                                  System.Windows.MessageBoxButton.OK, 
                                                  System.Windows.MessageBoxImage.Error);
                }
            }, "导出日志");
        }

        /// <summary>
        /// 打开设置
        /// </summary>
        private void ExecuteOpenSettings()
        {
            SafeExecute(() =>
            {
                // TODO: 实现设置对话框
                UpdateMainStatus("打开插件设置");
                LogManager.Info("打开设置");
            }, "打开设置");
        }

        /// <summary>
        /// 重置设置
        /// </summary>
        private void ExecuteResetSettings()
        {
            SafeExecute(() =>
            {
                // TODO: 实现设置重置功能
                UpdateMainStatus("设置已重置为默认值");
                IsAutoSaveEnabled = true;
                IsDebugModeEnabled = false;
                LogManager.Info("重置设置");
            }, "重置设置");
        }

        /// <summary>
        /// 导入配置
        /// </summary>
        private void ExecuteImportConfig()
        {
            SafeExecute(() =>
            {
                // TODO: 实现配置导入功能
                UpdateMainStatus("配置导入完成");
                LogManager.Info("导入配置");
            }, "导入配置");
        }

        /// <summary>
        /// 检查更新 (已优化为Idle事件监听)
        /// </summary>
        private void ExecuteCheckUpdate()
        {
            SafeExecute(() =>
            {
                UpdateMainStatus("正在检查更新...");
                
                // 使用Idle事件监听替代Thread.Sleep(2000)
                const string taskId = "SystemManagement_CheckUpdate";
                var startTime = DateTime.Now;
                
                IdleEventManager.Instance.RegisterOnceTask(
                    taskId,
                    () => (DateTime.Now - startTime).TotalMilliseconds >= 2000, // 2秒后条件满足
                    () =>
                    {
                        try
                        {
                            // 检查释放状态，避免在释放后更新UI
                            if (_disposed)
                            {
                                LogManager.Info("SystemManagementViewModel已释放，跳过更新检查UI更新");
                                return;
                            }
                            
                            UpdateMainStatus("当前版本已是最新版本");
                        }
                        catch (Exception ex)
                        {
                            LogManager.Error($"更新检查UI更新失败: {ex.Message}");
                        }
                    },
                    8 // 高优先级
                );
                
                LogManager.Info("检查更新 (使用Idle事件监听)");
            }, "检查更新");
        }

        /// <summary>
        /// 生成性能报告 (已优化为Idle事件监听)
        /// </summary>
        private void ExecuteGeneratePerformanceReport()
        {
            SafeExecute(() =>
            {
                UpdateMainStatus("正在生成性能报告...");
                
                // 使用Idle事件监听替代Thread.Sleep(1500)
                const string taskId = "SystemManagement_GenerateReport";
                var startTime = DateTime.Now;
                
                IdleEventManager.Instance.RegisterOnceTask(
                    taskId,
                    () => (DateTime.Now - startTime).TotalMilliseconds >= 1500, // 1.5秒后条件满足
                    () =>
                    {
                        try
                        {
                            // 检查释放状态，避免在释放后更新UI
                            if (_disposed)
                            {
                                LogManager.Info("SystemManagementViewModel已释放，跳过性能报告UI更新");
                                return;
                            }
                            
                            UpdateMainStatus("性能报告生成完成");
                            // 性能信息更新已合并到统一状态栏
                        }
                        catch (Exception ex)
                        {
                            LogManager.Error($"性能报告UI更新失败: {ex.Message}");
                        }
                    },
                    8 // 高优先级
                );
                
                LogManager.Info("生成性能报告 (使用Idle事件监听)");
            }, "生成性能报告");
        }

        /// <summary>
        /// 执行环境诊断
        /// </summary>
        private void ExecuteDiagnostic()
        {
            SafeExecute(() =>
            {
                try
                {
                    LogManager.Info("开始环境诊断");
                    
                    // 直接调用本地的环境诊断方法
                    string diagnosticReport = DiagnoseEnvironment();
                    
                    // 显示诊断结果对话框
                    System.Windows.MessageBox.Show(
                        diagnosticReport, 
                        "环境诊断结果", 
                        System.Windows.MessageBoxButton.OK, 
                        System.Windows.MessageBoxImage.Information);
                    
                    LogManager.Info("环境诊断完成");
                }
                catch (Exception ex)
                {
                    LogManager.Error($"环境诊断失败: {ex.Message}", ex);
                    System.Windows.MessageBox.Show(
                        $"环境诊断失败: {ex.Message}", 
                        "错误", 
                        System.Windows.MessageBoxButton.OK, 
                        System.Windows.MessageBoxImage.Error);
                }
            }, "环境诊断");
        }

        /// <summary>
        /// 环境诊断方法 - 快速检查API是否可用
        /// </summary>
        /// <returns>诊断报告</returns>
        private string DiagnoseEnvironment()
        {
            var report = new System.Text.StringBuilder();
            report.AppendLine("=== Navisworks API环境诊断报告 ===");
            
            try
            {
                // 1. 线程状态
                var apartmentState = System.Threading.Thread.CurrentThread.GetApartmentState();
                report.AppendLine($"线程状态: {apartmentState} {(apartmentState == System.Threading.ApartmentState.STA ? "✓" : "✗")}");
                
                // 2. API可用性
                try
                {
                    var app = Autodesk.Navisworks.Api.Application.ActiveDocument;
                    report.AppendLine("API可用性: 可用 ✓");
                }
                catch (Exception apiEx)
                {
                    report.AppendLine($"API可用性: 异常 - {apiEx.Message} ✗");
                }
                
                // 3. 文档状态
                try
                {
                    var document = Autodesk.Navisworks.Api.Application.ActiveDocument;
                    if (document != null)
                    {
                        report.AppendLine($"活动文档: {document.FileName ?? "未命名"} ✓");
                        report.AppendLine($"模型数量: {document.Models?.Count ?? 0}");
                    }
                    else
                    {
                        report.AppendLine("活动文档: 无 ✗");
                    }
                }
                catch (Exception docEx)
                {
                    report.AppendLine($"活动文档: 异常 - {docEx.Message} ✗");
                }
                
                // 4. 内存状态
                long memoryMB = GC.GetTotalMemory(false) / 1024 / 1024;
                report.AppendLine($"当前内存: {memoryMB} MB");
                
                // 5. 系统信息
                report.AppendLine($"插件版本: {PluginVersion}");
                report.AppendLine($"Navisworks版本: {NavisworksVersion}");
                report.AppendLine("系统状态: 正常");
                
                report.AppendLine("=== 诊断完成 ===");
                
                string result = report.ToString();
                LogManager.Info($"[SystemManagement] 环境诊断报告:\n{result}");
                return result;
            }
            catch (Exception ex)
            {
                string error = $"诊断过程出错: {ex.Message}";
                report.AppendLine(error);
                LogManager.Error($"[SystemManagement] {error}");
                return report.ToString();
            }
        }

        #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 SafeExecute(Action action, string operationName = "未知操作")
        {
            try
            {
                action();
            }
            catch (Exception ex)
            {
                LogManager.Error($"{operationName}发生异常: {ex.Message}", ex);
                UpdateMainStatus($"{operationName}失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 验证ViewModel状态是否正常
        /// </summary>
        public bool IsValidState()
        {
            return _uiStateManager != null && 
                   LogLevels != null;
        }

        /// <summary>
        /// 获取ViewModel状态信息
        /// </summary>
        public string GetStateInfo()
        {
            return $"UIStateManager: {(_uiStateManager != null ? "已初始化" : "未初始化")}, " +
                   $"日志级别数量: {LogLevels?.Count ?? 0}";
        }

        #endregion

        #region 清理资源和IDisposable实现

        /// <summary>
        /// 释放资源
        /// </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("SystemManagementViewModel已正确释放资源 (IDisposable)");
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"SystemManagementViewModel释放资源时发生异常: {ex.Message}", ex);
                    }
                }
                _disposed = true;
            }
        }

        public void Cleanup()
        {
            try
            {
                LogManager.Info("开始清理SystemManagementViewModel资源");
                
                // 停止性能监控Idle任务，替代DispatcherTimer清理
                try
                {
                    IdleEventManager.Instance.UnregisterTask("SystemManagement_PerformanceMonitor");
                    LogManager.Info("SystemManagementViewModel性能监控Idle任务已停止");
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"停止性能监控Idle任务时出现警告: {ex.Message}");
                }
                
                // 清理可能的一次性任务
                try
                {
                    IdleEventManager.Instance.UnregisterTask("SystemManagement_CheckUpdate");
                    IdleEventManager.Instance.UnregisterTask("SystemManagement_GenerateReport");
                    LogManager.Debug("SystemManagementViewModel一次性Idle任务已清理");
                }
                catch (Exception ex)
                {
                    LogManager.Debug($"清理一次性Idle任务时出现提示: {ex.Message}");
                }
                
                LogManager.Info("SystemManagementViewModel资源清理完成");
            }
            catch (Exception ex)
            {
                LogManager.Error($"SystemManagementViewModel清理失败: {ex.Message}");
            }
        }

        #endregion
    }
}