using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace NavisworksTransport.Core
{
    /// <summary>
    /// UI状态管理器 - 提供线程安全的UI更新机制
    /// 解决Navisworks插件中的跨线程UI操作问题，防止崩溃和死锁
    /// </summary>
    public class UIStateManager
    {
        #region 字段和属性

        private static UIStateManager _instance;
        private static readonly object _instanceLock = new object();

        private readonly SynchronizationContext _uiContext;
        private readonly object _operationLock = new object();
        private readonly ConcurrentQueue<UIUpdateOperation> _updateQueue;
        private readonly int _flushInterval = 50; // 50ms最小处理间隔，与UI刷新同步
        private volatile bool _isProcessing = false;
        private volatile bool _isDisposed = false;

        /// <summary>
        /// UI操作默认超时时间（毫秒）- 60秒
        /// 设置较长时间以应对程序性能异常导致的UI线程阻塞
        /// </summary>
        private const int DEFAULT_UI_TIMEOUT = 60000;

        /// <summary>
        /// 获取UIStateManager的单例实例
        /// </summary>
        public static UIStateManager Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_instanceLock)
                    {
                        if (_instance == null)
                        {
                            _instance = new UIStateManager();
                        }
                    }
                }
                return _instance;
            }
        }

        /// <summary>
        /// 获取当前是否在UI线程中
        /// </summary>
        public bool IsUIThread
        {
            get
            {
                if (_uiContext != null)
                {
                    return SynchronizationContext.Current == _uiContext;
                }

                // 回退到Windows Forms检查
                try
                {
                    var activeForm = Form.ActiveForm;
                    if (activeForm != null)
                    {
                        return !activeForm.InvokeRequired;
                    }
                    return false;
                }
                catch
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 获取当前等待处理的UI更新操作数量
        /// </summary>
        public int PendingOperationsCount => _updateQueue.Count;

        #endregion

        #region 构造函数和初始化

        private UIStateManager()
        {
            try
            {
                // 尝试获取当前的SynchronizationContext
                _uiContext = SynchronizationContext.Current;
                
                // 在Navisworks插件环境中，完全跳过WPF Dispatcher的创建
                // 因为它可能与宿主环境冲突并导致崩溃
                if (_uiContext == null)
                {
                    LogManager.Info("当前没有SynchronizationContext，UIStateManager将使用Windows Forms回退机制");
                    // 不尝试创建WPF Dispatcher，直接使用null让后续代码使用Windows Forms
                }

                _updateQueue = new ConcurrentQueue<UIUpdateOperation>();

                LogManager.Info("UIStateManager初始化完成");
            }
            catch (Exception ex)
            {
                LogManager.Error($"UIStateManager初始化失败: {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 手动设置UI上下文（通常在主线程初始化时调用）
        /// </summary>
        /// <param name="context">UI线程的SynchronizationContext</param>
        public void SetUIContext(SynchronizationContext context)
        {
            if (context == null)
            {
                LogManager.Warning("尝试设置空的SynchronizationContext");
                return;
            }

            // 只有在当前没有上下文或者在UI线程中才允许设置
            if (_uiContext == null || IsUIThread)
            {
                var oldContext = _uiContext;
                var newContext = context;
                
                LogManager.Info($"UIStateManager上下文更新: {oldContext?.GetType()?.Name} -> {newContext.GetType().Name}");
            }
            else
            {
                LogManager.Warning("只能在UI线程中设置SynchronizationContext");
            }
        }

        #endregion

        #region 核心UI更新接口

        /// <summary>
        /// 线程安全的异步UI更新操作
        /// </summary>
        /// <typeparam name="T">返回值类型</typeparam>
        /// <param name="operation">要执行的UI操作</param>
        /// <param name="timeout">超时时间（毫秒），默认5000ms</param>
        /// <returns>操作结果</returns>
        public async Task<T> ExecuteUIUpdateAsync<T>(Func<T> operation, int timeout = DEFAULT_UI_TIMEOUT)
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(UIStateManager));
            }

            if (operation == null)
            {
                throw new ArgumentNullException(nameof(operation));
            }

            // 如果已经在UI线程中，直接执行
            if (IsUIThread)
            {
                try
                {
                    return operation();
                }
                catch (Exception ex)
                {
                    LogManager.Error($"UI操作执行失败: {ex.Message}");
                    throw;
                }
            }

            // 创建任务完成信号
            var tcs = new TaskCompletionSource<T>();
            var cancellationToken = new CancellationTokenSource(timeout);

            // 设置超时处理
            cancellationToken.Token.Register(() =>
            {
                if (!tcs.Task.IsCompleted)
                {
                    // 记录警告日志，但不抛出异常（批处理等长时间操作可能需要更长时间）
                    LogManager.Warning($"UI操作超时（{timeout}ms），但操作可能仍在后台执行中");
                    
                    // 对于长时间操作（如批处理），超时不应该是错误
                    // 设置结果为默认值，让调用者决定如何处理
                    tcs.TrySetResult(default(T));
                }
            });

            try
            {
                // 使用SynchronizationContext切换到UI线程
                if (_uiContext != null)
                {
                    _uiContext.Post(_ =>
                    {
                        try
                        {
                            if (!cancellationToken.Token.IsCancellationRequested)
                            {
                                var result = operation();
                                tcs.TrySetResult(result);
                            }
                        }
                        catch (Exception ex)
                        {
                            LogManager.Error($"UI线程操作异常: {ex.Message}");
                            tcs.TrySetException(ex);
                        }
                    }, null);
                }
                else
                {
                    // 回退到Control.BeginInvoke
                    var mainForm = GetMainForm();
                    if (mainForm != null)
                    {
                        mainForm.BeginInvoke(new Action(() =>
                        {
                            try
                            {
                                if (!cancellationToken.Token.IsCancellationRequested)
                                {
                                    var result = operation();
                                    tcs.TrySetResult(result);
                                }
                            }
                            catch (Exception ex)
                            {
                                LogManager.Error($"UI线程操作异常（Control.BeginInvoke）: {ex.Message}");
                                tcs.TrySetException(ex);
                            }
                        }));
                    }
                    else
                    {
                        throw new InvalidOperationException("无法找到UI上下文来执行操作");
                    }
                }

                return await tcs.Task;
            }
            finally
            {
                // 延迟释放，给异步操作清理时间，避免"CancellationTokenSource 已释放"异常
                _ = Task.Delay(100).ContinueWith(_ => cancellationToken.Dispose());
            }
        }

        /// <summary>
        /// 无返回值的异步UI更新操作
        /// </summary>
        /// <param name="operation">要执行的UI操作</param>
        /// <param name="timeout">超时时间（毫秒），默认5000ms</param>
        public async Task ExecuteUIUpdateAsync(Action operation, int timeout = DEFAULT_UI_TIMEOUT)
        {
            await ExecuteUIUpdateAsync<object>(() =>
            {
                operation();
                return null;
            }, timeout);
        }

        #endregion

        #region 批量UI更新接口

        /// <summary>
        /// 批量执行UI更新操作（原子性保证）
        /// 所有操作要么全部成功，要么全部失败
        /// </summary>
        /// <param name="updates">要执行的UI更新操作数组</param>
        /// <param name="timeout">超时时间（毫秒），默认10000ms</param>
        public async Task ExecuteBatchUIUpdate(Action[] updates, int timeout = DEFAULT_UI_TIMEOUT)
        {
            if (updates == null || updates.Length == 0)
            {
                return;
            }

            await ExecuteUIUpdateAsync(() =>
            {
                var exceptions = new List<Exception>();

                // 执行所有更新操作
                foreach (var update in updates)
                {
                    try
                    {
                        update?.Invoke();
                    }
                    catch (Exception ex)
                    {
                        exceptions.Add(ex);
                        LogManager.Error($"批量UI更新中的操作失败: {ex.Message}");
                    }
                }

                // 如果有任何异常，抛出聚合异常
                if (exceptions.Count > 0)
                {
                    throw new AggregateException("批量UI更新过程中发生错误", exceptions);
                }
            }, timeout);
        }

        /// <summary>
        /// 批量执行UI更新操作（可变参数版本）
        /// </summary>
        /// <param name="updates">要执行的UI更新操作</param>
        public async Task ExecuteBatchUIUpdate(params Action[] updates)
        {
            await ExecuteBatchUIUpdate(updates, DEFAULT_UI_TIMEOUT);
        }

        /// <summary>
        /// 同步版本的批量UI更新操作（用于强制同步处理）
        /// 不使用异步机制，直接在当前线程中处理UI操作
        /// </summary>
        /// <param name="updates">要执行的UI更新操作数组</param>
        /// <param name="timeout">超时时间（毫秒），默认5000ms</param>
        public void ExecuteBatchUIUpdateSync(Action[] updates, int timeout = DEFAULT_UI_TIMEOUT)
        {
            if (updates == null || updates.Length == 0)
            {
                return;
            }

            LogManager.Info($"开始同步执行{updates.Length}个UI更新操作");

            var exceptions = new List<Exception>();

            // 如果已经在UI线程中，直接执行
            if (IsUIThread)
            {
                LogManager.Info("当前已在UI线程，直接同步执行批量操作");
                foreach (var update in updates)
                {
                    try
                    {
                        update?.Invoke();
                    }
                    catch (Exception ex)
                    {
                        exceptions.Add(ex);
                        LogManager.Error($"同步批量UI更新中的操作失败: {ex.Message}");
                    }
                }
            }
            else
            {
                // 使用同步方式切换到UI线程
                var completed = false;
                Exception syncException = null;
                var resetEvent = new ManualResetEventSlim(false);

                LogManager.Info("切换到UI线程同步执行批量操作");

                if (_uiContext != null)
                {
                    _uiContext.Send(_ =>
                    {
                        try
                        {
                            LogManager.Info($"SynchronizationContext中同步执行{updates.Length}个操作");
                            foreach (var update in updates)
                            {
                                try
                                {
                                    update?.Invoke();
                                }
                                catch (Exception ex)
                                {
                                    exceptions.Add(ex);
                                    LogManager.Error($"同步批量UI更新中的操作失败: {ex.Message}");
                                }
                            }
                            completed = true;
                        }
                        catch (Exception ex)
                        {
                            syncException = ex;
                        }
                        finally
                        {
                            resetEvent.Set();
                        }
                    }, null);
                }
                else
                {
                    // 回退到Control.Invoke
                    var mainForm = GetMainForm();
                    if (mainForm != null)
                    {
                        mainForm.Invoke(new Action(() =>
                        {
                            try
                            {
                                LogManager.Info($"Control.Invoke中同步执行{updates.Length}个操作");
                                foreach (var update in updates)
                                {
                                    try
                                    {
                                        update?.Invoke();
                                    }
                                    catch (Exception ex)
                                    {
                                        exceptions.Add(ex);
                                        LogManager.Error($"同步批量UI更新中的操作失败: {ex.Message}");
                                    }
                                }
                                completed = true;
                            }
                            catch (Exception ex)
                            {
                                syncException = ex;
                            }
                            finally
                            {
                                resetEvent.Set();
                            }
                        }));
                    }
                    else
                    {
                        throw new InvalidOperationException("无法找到UI上下文来执行同步批量UI更新");
                    }
                }

                // 等待完成或超时
                if (!resetEvent.Wait(timeout))
                {
                    LogManager.Error($"同步批量UI更新执行超时（{timeout}ms）");
                    throw new TimeoutException($"同步批量UI更新执行超时（{timeout}ms）");
                }

                // 检查执行结果
                if (syncException != null)
                {
                    throw new Exception("同步批量UI更新执行失败", syncException);
                }

                if (!completed)
                {
                    throw new InvalidOperationException("同步批量UI更新未正确完成");
                }
            }

            // 如果有任何异常，抛出聚合异常
            if (exceptions.Count > 0)
            {
                LogManager.Error($"同步批量UI更新过程中发生{exceptions.Count}个错误");
                throw new AggregateException("同步批量UI更新过程中发生错误", exceptions);
            }

            LogManager.Info($"同步批量UI更新成功完成{updates.Length}个操作");
        }

        #endregion

        #region 更新队列管理

        /// <summary>
        /// 将UI更新操作加入队列（用于批量处理）
        /// </summary>
        /// <param name="operation">UI更新操作</param>
        /// <param name="priority">操作优先级</param>
        public void QueueUIUpdate(Action operation, UIUpdatePriority priority = UIUpdatePriority.Normal, bool forceSync = false)
        {
            if (_isDisposed || operation == null)
            {
                return;
            }

            var updateOperation = new UIUpdateOperation
            {
                Id = Guid.NewGuid(),
                Operation = operation,
                Priority = priority,
                QueueTime = DateTime.UtcNow
            };

            _updateQueue.Enqueue(updateOperation);

            // 如果当前没有在处理，根据参数选择处理方式
            if (!_isProcessing)
            {
                if (forceSync || priority == UIUpdatePriority.Critical)
                {
                    // 强制同步处理：直接处理队列，不依赖Task.Run
                    LogManager.Info($"强制同步处理UI队列，优先级: {priority}, 队列长度: {_updateQueue.Count}");
                    try
                    {
                        ProcessQueuedUpdates(forcedSync: true).GetAwaiter().GetResult();
                    }
                    catch (Exception ex)
                    {
                        LogManager.Error($"强制同步处理队列失败: {ex.Message}");
                        // 回退到异步处理
                        _ = Task.Run(() => ProcessQueuedUpdates(forcedSync: false));
                        EnsureIdleProcessorRunning();
                    }
                }
                else
                {
                    // 普通异步处理 + 保底定时器
                    _ = Task.Run(() => ProcessQueuedUpdates(forcedSync: false));
                    EnsureIdleProcessorRunning();
                }
            }
        }

        /// <summary>
        /// 强制同步处理UI更新操作（便捷方法）
        /// 操作会先入队，然后立即同步处理整个队列
        /// </summary>
        /// <param name="operation">UI更新操作</param>
        /// <param name="priority">操作优先级</param>
        /// <param name="operationType">操作类型描述，用于日志记录</param>
        public void QueueUIUpdateWithForcedSync(Action operation, UIUpdatePriority priority = UIUpdatePriority.High, string operationType = "强制同步UI更新")
        {
            LogManager.Info($"*** 开始{operationType}，优先级: {priority} ***");
            QueueUIUpdate(operation, priority, forceSync: true);
            LogManager.Info($"*** {operationType}完成 ***");
        }

        /// <summary>
        /// 强制刷新当前队列中的所有操作（不添加新操作）
        /// 直接同步处理现有队列，代替Task.Run
        /// </summary>
        /// <param name="operationType">操作类型描述，用于日志记录</param>
        public void ForceFlushQueue(string operationType = "强制刷新队列")
        {
            if (_updateQueue.IsEmpty)
            {
                LogManager.Info($"{operationType}: 队列为空，无需处理");
                return;
            }

            if (_isProcessing)
            {
                LogManager.Info($"{operationType}: 已在处理中，跳过");
                return;
            }

            LogManager.Info($"*** 开始{operationType}，当前队列长度: {_updateQueue.Count} ***");
            
            try
            {
                ProcessQueuedUpdates(forcedSync: true).GetAwaiter().GetResult();
                LogManager.Info($"*** {operationType}成功完成 ***");
            }
            catch (Exception ex)
            {
                LogManager.Error($"*** {operationType}失败: {ex.Message} ***");
                throw;
            }
        }

        /// <summary>
        /// 立即执行UI更新操作，绕过队列机制
        /// 用于关键UI事件（如RouteGenerated）需要立即响应的场景
        /// </summary>
        /// <param name="operation">要执行的UI操作</param>
        /// <param name="operationType">操作类型描述，用于日志记录</param>
        /// <param name="timeout">超时时间（毫秒），默认2000ms</param>
        public void ExecuteImmediateUIUpdate(Action operation, string operationType = "立即UI更新", int timeout = DEFAULT_UI_TIMEOUT)
        {
            if (_isDisposed || operation == null)
            {
                LogManager.Warning($"跳过{operationType}：UIStateManager已释放或操作为null");
                return;
            }

            try
            {
                LogManager.Info($"*** 开始立即执行{operationType} ***");

                // 如果已经在UI线程中，直接执行
                if (IsUIThread)
                {
                    LogManager.Info($"*** 当前已在UI线程，直接执行{operationType} ***");
                    operation();
                    LogManager.Info($"*** {operationType}立即执行完成 ***");
                    return;
                }

                // 创建同步等待信号
                var completed = false;
                Exception exception = null;
                var resetEvent = new ManualResetEventSlim(false);

                LogManager.Info($"*** 切换到UI线程执行{operationType} ***");

                // 使用同步方式切换到UI线程
                if (_uiContext != null)
                {
                    _uiContext.Send(_ =>
                    {
                        try
                        {
                            LogManager.Info($"*** SynchronizationContext中执行{operationType} ***");
                            operation();
                            completed = true;
                        }
                        catch (Exception ex)
                        {
                            exception = ex;
                            LogManager.Error($"{operationType}在UI线程中执行失败: {ex.Message}");
                        }
                        finally
                        {
                            resetEvent.Set();
                        }
                    }, null);
                }
                else
                {
                    // 回退到Control.Invoke
                    var mainForm = GetMainForm();
                    if (mainForm != null)
                    {
                        mainForm.Invoke(new Action(() =>
                        {
                            try
                            {
                                LogManager.Info($"*** Control.Invoke中执行{operationType} ***");
                                operation();
                                completed = true;
                            }
                            catch (Exception ex)
                            {
                                exception = ex;
                                LogManager.Error($"{operationType}在UI线程中执行失败（Control.Invoke）: {ex.Message}");
                            }
                            finally
                            {
                                resetEvent.Set();
                            }
                        }));
                    }
                    else
                    {
                        throw new InvalidOperationException($"无法找到UI上下文来执行{operationType}");
                    }
                }

                // 等待完成或超时
                if (!resetEvent.Wait(timeout))
                {
                    LogManager.Error($"*** {operationType}执行超时（{timeout}ms） ***");
                    throw new TimeoutException($"{operationType}执行超时（{timeout}ms）");
                }

                // 检查执行结果
                if (exception != null)
                {
                    throw new Exception($"{operationType}执行失败", exception);
                }

                if (!completed)
                {
                    throw new InvalidOperationException($"{operationType}未正确完成");
                }

                LogManager.Info($"*** {operationType}立即执行成功完成 ***");
            }
            catch (Exception ex)
            {
                LogManager.Error($"*** {operationType}立即执行失败: {ex.Message} ***", ex);
                throw;
            }
        }

        /// <summary>
        /// 确保Idle处理器在运行（处理可能积压的UI操作）
        /// 作为队列处理的保底机制，防止Task.Run失败导致的队列积压
        /// </summary>
        private void EnsureIdleProcessorRunning()
        {
            try
            {
                // 如果队列为空，则不需要启动
                if (_updateQueue.IsEmpty)
                {
                    return;
                }

                // 注册到IdleEventManager
                const string taskId = "UIStateManager_QueueProcessor";
                
                IdleEventManager.Instance.RegisterTask(
                    taskId, 
                    ProcessQueueOnIdle, 
                    _flushInterval, // 最小间隔50ms
                    10 // 高优先级，UI更新很重要
                );
            }
            catch (Exception ex)
            {
                LogManager.Error($"注册Idle处理器失败: {ex.Message}");
            }
        }

        /// <summary>
        /// Idle事件处理器 - 检查并处理积压的队列
        /// </summary>
        private void ProcessQueueOnIdle()
        {
            try
            {
                // 如果没有积压的操作，取消注册Idle任务
                if (_updateQueue.IsEmpty)
                {
                    IdleEventManager.Instance.UnregisterTask("UIStateManager_QueueProcessor");
                    return;
                }

                // 如果当前正在处理，等待下次检查
                if (_isProcessing)
                {
                    return;
                }

                LogManager.Info($"Idle事件检测到队列积压({_updateQueue.Count}个操作)，开始处理");
                
                // 强制启动队列处理（Idle事件使用异步处理）
                _ = Task.Run(() => ProcessQueuedUpdates(forcedSync: false));
            }
            catch (Exception ex)
            {
                LogManager.Error($"Idle队列处理失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 停止Idle队列处理器
        /// </summary>
        private void StopIdleProcessor()
        {
            try
            {
                IdleEventManager.Instance.UnregisterTask("UIStateManager_QueueProcessor");
                LogManager.Info("已停止Idle队列处理器");
            }
            catch (Exception ex)
            {
                LogManager.Error($"停止Idle队列处理器失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 处理队列中的UI更新操作
        /// </summary>
        /// <param name="forcedSync">是否强制同步处理（不使用异步）</param>
        private async Task ProcessQueuedUpdates(bool forcedSync = false)
        {
            lock (_operationLock)
            {
                if (_isProcessing)
                {
                    return; // 防止重入
                }
                _isProcessing = true;
            }

            try
            {
                while (true)
                {
                    var operations = new List<UIUpdateOperation>();

                    // 收集当前队列中的所有操作
                    while (_updateQueue.TryDequeue(out var operation))
                    {
                        operations.Add(operation);
                    }

                    if (operations.Count == 0)
                    {
                        break;
                    }

                    // 按优先级排序
                    operations = operations.OrderByDescending(op => op.Priority).ToList();

                    LogManager.Info($"开始处理{operations.Count}个排队的UI更新操作，强制同步: {forcedSync}");

                    // 批量执行操作
                    var actions = operations.Select(op => op.Operation).ToArray();

                    if (forcedSync)
                    {
                        // 使用同步版本的批量更新
                        LogManager.Info("使用同步方式处理UI更新队列");
                        ExecuteBatchUIUpdateSync(actions);
                        LogManager.Info($"同步处理{operations.Count}个UI更新操作完成");
                    }
                    else
                    {
                        // 使用异步版本的批量更新
                        LogManager.Info("使用异步方式处理UI更新队列");
                        await ExecuteBatchUIUpdate(actions);
                        LogManager.Info($"异步处理{operations.Count}个UI更新操作完成");
                    }

                    if (_updateQueue.IsEmpty)
                    {
                        StopIdleProcessor();
                        break;
                    }

                    LogManager.Info($"检测到执行过程中新增 {_updateQueue.Count} 个UI更新操作，继续处理后续批次");
                }
            }
            catch (Exception ex)
            {
                LogManager.Error($"处理UI更新队列时发生错误: {ex.Message}");
            }
            finally
            {
                lock (_operationLock)
                {
                    _isProcessing = false;
                }
            }
        }

        /// <summary>
        /// 清空待处理的UI更新队列
        /// </summary>
        public void ClearUpdateQueue()
        {
            var count = 0;
            while (_updateQueue.TryDequeue(out _))
            {
                count++;
            }

            if (count > 0)
            {
                LogManager.Info($"清空了{count}个待处理的UI更新操作");
            }
        }

        #endregion

        #region 辅助方法

        /// <summary>
        /// 获取主窗体用于线程调用
        /// </summary>
        /// <returns>主窗体或null</returns>
        private Control GetMainForm()
        {
            try
            {
                // 尝试获取当前活动窗体
                var activeForm = Form.ActiveForm;
                if (activeForm != null)
                {
                    return activeForm;
                }

                // 尝试获取应用程序主窗体
                if (Application.OpenForms.Count > 0)
                {
                    return Application.OpenForms[0];
                }

                return null;
            }
            catch (Exception ex)
            {
                LogManager.Warning($"获取主窗体失败: {ex.Message}");
                return null;
            }
        }

        #endregion

        #region IDisposable实现

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            if (_isDisposed)
            {
                return;
            }

            _isDisposed = true;

            // 停止并清理保底定时器
            StopIdleProcessor();
            
            // 清空队列
            ClearUpdateQueue();

            LogManager.Info("UIStateManager已释放");
        }

        #endregion
    }

    #region 支持类和枚举

    /// <summary>
    /// UI更新操作封装
    /// </summary>
    internal class UIUpdateOperation
    {
        public Guid Id { get; set; }
        public Action Operation { get; set; }
        public UIUpdatePriority Priority { get; set; }
        public DateTime QueueTime { get; set; }
    }

    /// <summary>
    /// UI更新操作优先级
    /// </summary>
    public enum UIUpdatePriority
    {
        /// <summary>
        /// 低优先级 - 非关键UI更新
        /// </summary>
        Low = 0,

        /// <summary>
        /// 普通优先级 - 标准UI更新
        /// </summary>
        Normal = 1,

        /// <summary>
        /// 高优先级 - 重要UI更新
        /// </summary>
        High = 2,

        /// <summary>
        /// 关键优先级 - 关键UI更新，最优先处理
        /// </summary>
        Critical = 3
    }

    #endregion
}
