using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using Microsoft.Win32;
using Newtonsoft.Json;

namespace Ink_Canvas.Helpers
{
    /// <summary>
    /// 设备标识符和使用频率监控类
    /// </summary>
    internal static class DeviceIdentifier
    {
        // 多重备份路径策略
        private static readonly string DeviceIdFilePath = Path.Combine(App.RootPath, "device_id.dat");
        private static readonly string UsageStatsFilePath = Path.Combine(App.RootPath, "usage_stats.json");

        // 使用频率数据的多重隐藏备份路径
        private static readonly string BackupDeviceIdPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
            "ICC", ".sys", "device.dat");
        private static readonly string BackupUsageStatsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
            "ICC", ".sys", "usage.dat");

        // 使用频率数据的额外隐藏备份位置
        private static readonly string SecondaryUsageBackupPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
            "Microsoft", "Windows", ".icc", "usage_backup.tmp");
        private static readonly string TertiaryUsageBackupPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
            "ICC", ".cache", "usage_cache.dat");
        private static readonly string QuaternaryUsageBackupPath = Path.Combine(Path.GetTempPath(),
            ".icc_temp", "usage_temp.dat");

        // 数据完整性验证密钥
        private static readonly string DataIntegrityKey = "ICC_DEVICE_INTEGRITY_2024";

        private static readonly string DeviceId;
        private static readonly object fileLock = new object();

        static DeviceIdentifier()
        {
            // 在静态构造函数中初始化设备ID
            DeviceId = GetOrCreateDeviceId();

            // 执行数据完整性检查和自动修复
            try
            {
                PerformDataIntegrityCheck();
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 初始化时数据完整性检查失败: {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 获取或创建设备ID
        /// </summary>
        /// <returns>25字符的唯一设备标识符</returns>
        public static string GetDeviceId()
        {
            return DeviceId;
        }

        /// <summary>
        /// 获取或创建设备ID（内部方法）- 支持多重备份恢复
        /// </summary>
        private static string GetOrCreateDeviceId()
        {
            lock (fileLock)
            {
                try
                {
                    // 1. 尝试从主文件读取设备ID
                    string deviceId = LoadDeviceIdFromFile(DeviceIdFilePath);
                    if (!string.IsNullOrEmpty(deviceId))
                    {
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 从主文件读取设备ID: {deviceId}");
                        // 确保备份同步
                        SaveDeviceIdToAllLocations(deviceId);
                        return deviceId;
                    }

                    // 2. 尝试从备份文件恢复
                    deviceId = LoadDeviceIdFromFile(BackupDeviceIdPath);
                    if (!string.IsNullOrEmpty(deviceId))
                    {
                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 从备份文件恢复设备ID: {deviceId}");
                        SaveDeviceIdToAllLocations(deviceId);
                        return deviceId;
                    }

                    // 3. 尝试从注册表恢复
                    deviceId = LoadDeviceIdFromRegistry();
                    if (!string.IsNullOrEmpty(deviceId))
                    {
                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 从注册表恢复设备ID: {deviceId}");
                        SaveDeviceIdToAllLocations(deviceId);
                        return deviceId;
                    }

                    // 4. 生成新的设备ID
                    string newDeviceId = GenerateDeviceId();
                    LogHelper.WriteLogToFile($"DeviceIdentifier | 生成新设备ID: {newDeviceId}");

                    // 5. 保存到所有位置
                    SaveDeviceIdToAllLocations(newDeviceId);

                    return newDeviceId;
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogToFile($"DeviceIdentifier | 获取设备ID时出错: {ex.Message}", LogHelper.LogType.Error);
                    // 返回一个基于时间戳的备用ID
                    return GenerateFallbackDeviceId();
                }
            }
        }

        /// <summary>
        /// 生成25字符的唯一设备ID
        /// </summary>
        private static string GenerateDeviceId()
        {
            try
            {
                // 收集硬件信息
                var hardwareInfo = new StringBuilder();
                
                // 使用反射获取硬件信息，避免直接引用System.Management
                try
                {
                    // 尝试加载System.Management程序集
                    var assembly = Assembly.Load("System.Management");
                    if (assembly != null)
                    {
                        // CPU信息
                        try
                        {
                            var searcherType = assembly.GetType("System.Management.ManagementObjectSearcher");
                            var searcher = Activator.CreateInstance(searcherType, "SELECT ProcessorId FROM Win32_Processor");
                            var getMethod = searcherType.GetMethod("Get");
                            var enumerator = getMethod.Invoke(searcher, null);
                            
                            var moveNextMethod = enumerator.GetType().GetMethod("MoveNext");
                            var currentProperty = enumerator.GetType().GetProperty("Current");
                            
                            if ((bool)moveNextMethod.Invoke(enumerator, null))
                            {
                                var obj = currentProperty.GetValue(enumerator);
                                var indexer = obj.GetType().GetProperty("Item", new[] { typeof(string) });
                                var processorId = indexer.GetValue(obj, new object[] { "ProcessorId" });
                                hardwareInfo.Append(processorId?.ToString() ?? "");
                            }
                            
                            var disposeMethod = searcher.GetType().GetMethod("Dispose");
                            disposeMethod?.Invoke(searcher, null);
                        }
                        catch { }

                        // 主板序列号
                        try
                        {
                            var searcherType = assembly.GetType("System.Management.ManagementObjectSearcher");
                            var searcher = Activator.CreateInstance(searcherType, "SELECT SerialNumber FROM Win32_BaseBoard");
                            var getMethod = searcherType.GetMethod("Get");
                            var enumerator = getMethod.Invoke(searcher, null);
                            
                            var moveNextMethod = enumerator.GetType().GetMethod("MoveNext");
                            var currentProperty = enumerator.GetType().GetProperty("Current");
                            
                            if ((bool)moveNextMethod.Invoke(enumerator, null))
                            {
                                var obj = currentProperty.GetValue(enumerator);
                                var indexer = obj.GetType().GetProperty("Item", new[] { typeof(string) });
                                var serialNumber = indexer.GetValue(obj, new object[] { "SerialNumber" });
                                hardwareInfo.Append(serialNumber?.ToString() ?? "");
                            }
                            
                            var disposeMethod = searcher.GetType().GetMethod("Dispose");
                            disposeMethod?.Invoke(searcher, null);
                        }
                        catch { }

                        // BIOS序列号
                        try
                        {
                            var searcherType = assembly.GetType("System.Management.ManagementObjectSearcher");
                            var searcher = Activator.CreateInstance(searcherType, "SELECT SerialNumber FROM Win32_BIOS");
                            var getMethod = searcherType.GetMethod("Get");
                            var enumerator = getMethod.Invoke(searcher, null);
                            
                            var moveNextMethod = enumerator.GetType().GetMethod("MoveNext");
                            var currentProperty = enumerator.GetType().GetProperty("Current");
                            
                            if ((bool)moveNextMethod.Invoke(enumerator, null))
                            {
                                var obj = currentProperty.GetValue(enumerator);
                                var indexer = obj.GetType().GetProperty("Item", new[] { typeof(string) });
                                var serialNumber = indexer.GetValue(obj, new object[] { "SerialNumber" });
                                hardwareInfo.Append(serialNumber?.ToString() ?? "");
                            }
                            
                            var disposeMethod = searcher.GetType().GetMethod("Dispose");
                            disposeMethod?.Invoke(searcher, null);
                        }
                        catch { }

                        // 主硬盘序列号
                        try
                        {
                            var searcherType = assembly.GetType("System.Management.ManagementObjectSearcher");
                            var searcher = Activator.CreateInstance(searcherType, "SELECT SerialNumber FROM Win32_DiskDrive WHERE MediaType='Fixed hard disk media'");
                            var getMethod = searcherType.GetMethod("Get");
                            var enumerator = getMethod.Invoke(searcher, null);
                            
                            var moveNextMethod = enumerator.GetType().GetMethod("MoveNext");
                            var currentProperty = enumerator.GetType().GetProperty("Current");
                            
                            if ((bool)moveNextMethod.Invoke(enumerator, null))
                            {
                                var obj = currentProperty.GetValue(enumerator);
                                var indexer = obj.GetType().GetProperty("Item", new[] { typeof(string) });
                                var serialNumber = indexer.GetValue(obj, new object[] { "SerialNumber" });
                                hardwareInfo.Append(serialNumber?.ToString() ?? "");
                            }
                            
                            var disposeMethod = searcher.GetType().GetMethod("Dispose");
                            disposeMethod?.Invoke(searcher, null);
                        }
                        catch { }
                    }
                }
                catch { }

                // 如果硬件信息不足，添加系统信息
                if (hardwareInfo.Length < 10)
                {
                    hardwareInfo.Append(Environment.MachineName);
                    hardwareInfo.Append(Environment.UserName);
                    hardwareInfo.Append(Environment.OSVersion);
                }

                // 生成哈希
                using (var sha256 = SHA256.Create())
                {
                    byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(hardwareInfo.ToString()));
                    string hashString = BitConverter.ToString(hashBytes).Replace("-", "");

                    // 取前25个字符，确保唯一性
                    string deviceId = hashString.Substring(0, 25);
                    
                    // 添加校验位（第25位）
                    int checksum = 0;
                    for (int i = 0; i < 24; i++)
                    {
                        checksum += Convert.ToInt32(deviceId[i]);
                    }
                    checksum %= 36; // 0-9, A-Z
                    char checksumChar = checksum < 10 ? (char)(checksum + '0') : (char)(checksum - 10 + 'A');
                    
                    return deviceId.Substring(0, 24) + checksumChar;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 生成设备ID时出错: {ex.Message}", LogHelper.LogType.Error);
                return GenerateFallbackDeviceId();
            }
        }

        /// <summary>
        /// 生成备用设备ID（基于时间戳）
        /// </summary>
        private static string GenerateFallbackDeviceId()
        {
            try
            {
                string timestamp = DateTime.Now.Ticks.ToString("X");
                string random = Guid.NewGuid().ToString("N").Substring(0, 8);
                string combined = timestamp + random;
                
                using (var sha256 = SHA256.Create())
                {
                    byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(combined));
                    string hashString = BitConverter.ToString(hashBytes).Replace("-", "");
                    return hashString.Substring(0, 25);
                }
            }
            catch
            {
                // 最后的备用方案
                return "ICC" + DateTime.Now.ToString("yyyyMMddHHmmss") + "000000000";
            }
        }

        /// <summary>
        /// 验证设备ID格式
        /// </summary>
        private static bool IsValidDeviceId(string deviceId)
        {
            if (string.IsNullOrEmpty(deviceId) || deviceId.Length != 25)
                return false;

            // 验证字符集（只允许数字和大写字母）
            if (!deviceId.All(c => char.IsLetterOrDigit(c) && (char.IsDigit(c) || char.IsUpper(c))))
                return false;

            // 验证校验位
            try
            {
                int checksum = 0;
                for (int i = 0; i < 24; i++)
                {
                    checksum += Convert.ToInt32(deviceId[i]);
                }
                checksum %= 36;
                char expectedChecksum = checksum < 10 ? (char)(checksum + '0') : (char)(checksum - 10 + 'A');
                return deviceId[24] == expectedChecksum;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 从文件加载设备ID
        /// </summary>
        private static string LoadDeviceIdFromFile(string filePath)
        {
            try
            {
                if (File.Exists(filePath))
                {
                    string content = File.ReadAllText(filePath).Trim();
                    if (IsValidDeviceId(content))
                    {
                        return content;
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 从文件加载设备ID失败 ({filePath}): {ex.Message}", LogHelper.LogType.Error);
            }
            return null;
        }

        /// <summary>
        /// 从注册表加载设备ID
        /// </summary>
        private static string LoadDeviceIdFromRegistry()
        {
            try
            {
                using (var key = Registry.CurrentUser.OpenSubKey(@"Software\ICC\DeviceInfo"))
                {
                    if (key != null)
                    {
                        var value = key.GetValue("DeviceId") as string;
                        if (IsValidDeviceId(value))
                        {
                            return value;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 从注册表加载设备ID失败: {ex.Message}", LogHelper.LogType.Error);
            }
            return null;
        }

        /// <summary>
        /// 保存设备ID到所有位置
        /// </summary>
        private static void SaveDeviceIdToAllLocations(string deviceId)
        {
            // 保存到主文件
            SaveDeviceIdToFile(DeviceIdFilePath, deviceId);

            // 保存到备份文件
            SaveDeviceIdToFile(BackupDeviceIdPath, deviceId);

            // 保存到注册表
            SaveDeviceIdToRegistry(deviceId);
        }

        /// <summary>
        /// 保存设备ID到文件
        /// </summary>
        private static void SaveDeviceIdToFile(string filePath, string deviceId)
        {
            try
            {
                // 确保目录存在
                var directory = Path.GetDirectoryName(filePath);
                if (!Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                    // 设置隐藏属性
                    if (filePath.Contains(".sys"))
                    {
                        var dirInfo = new DirectoryInfo(directory);
                        dirInfo.Attributes |= FileAttributes.Hidden | FileAttributes.System;
                    }
                }

                File.WriteAllText(filePath, deviceId);

                // 设置文件属性为隐藏和系统文件
                if (filePath.Contains(".sys"))
                {
                    var fileInfo = new FileInfo(filePath);
                    fileInfo.Attributes |= FileAttributes.Hidden | FileAttributes.System;
                }

                // LogHelper.WriteLogToFile($"DeviceIdentifier | 设备ID已保存到: {filePath}");
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 保存设备ID到文件失败 ({filePath}): {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 保存设备ID到注册表
        /// </summary>
        private static void SaveDeviceIdToRegistry(string deviceId)
        {
            try
            {
                using (var key = Registry.CurrentUser.CreateSubKey(@"Software\ICC\DeviceInfo"))
                {
                    key?.SetValue("DeviceId", deviceId);
                    key?.SetValue("LastUpdate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                }
                // LogHelper.WriteLogToFile("DeviceIdentifier | 设备ID已保存到注册表");
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 保存设备ID到注册表失败: {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 使用频率统计数据结构（优化至秒级精度）
        /// </summary>
        private class UsageStats
        {
            [JsonProperty("deviceId")]
            public string DeviceId { get; set; }

            [JsonProperty("lastLaunchTime")]
            public DateTime LastLaunchTime { get; set; }

            [JsonProperty("launchCount")]
            public int LaunchCount { get; set; }

            // 新的秒级精度字段
            [JsonProperty("totalUsageSeconds")]
            public long TotalUsageSeconds { get; set; }

            [JsonProperty("averageSessionSeconds")]
            public double AverageSessionSeconds { get; set; }

            // 保留旧字段以保持向后兼容性（已弃用）
            [JsonProperty("totalUsageMinutes")]
            [Obsolete("已弃用，请使用 TotalUsageSeconds")]
            public long TotalUsageMinutes { get; set; }

            [JsonProperty("averageSessionMinutes")]
            [Obsolete("已弃用，请使用 AverageSessionSeconds")]
            public double AverageSessionMinutes { get; set; }

            [JsonProperty("lastUpdateCheck")]
            public DateTime LastUpdateCheck { get; set; }

            [JsonProperty("updatePriority")]
            public UpdatePriority UpdatePriority { get; set; }

            [JsonProperty("usageFrequency")]
            public UsageFrequency UsageFrequency { get; set; }

            [JsonProperty("dataHash")]
            public string DataHash { get; set; }

            [JsonProperty("lastModified")]
            public DateTime LastModified { get; set; }

            // 每周统计数据（秒级精度）
            [JsonProperty("weeklyLaunchCount")]
            public int WeeklyLaunchCount { get; set; }

            [JsonProperty("weeklyUsageSeconds")]
            public long WeeklyUsageSeconds { get; set; }

            [JsonProperty("weekStartDate")]
            public DateTime WeekStartDate { get; set; }

            [JsonProperty("lastWeekLaunchCount")]
            public int LastWeekLaunchCount { get; set; }

            [JsonProperty("lastWeekUsageSeconds")]
            public long LastWeekUsageSeconds { get; set; }

            // 保留旧字段以保持向后兼容性（已弃用）
            [JsonProperty("weeklyUsageMinutes")]
            [Obsolete("已弃用，请使用 WeeklyUsageSeconds")]
            public long WeeklyUsageMinutes { get; set; }

            [JsonProperty("lastWeekUsageMinutes")]
            [Obsolete("已弃用，请使用 LastWeekUsageSeconds")]
            public long LastWeekUsageMinutes { get; set; }

            /// <summary>
            /// 数据迁移：从分钟精度迁移到秒级精度
            /// </summary>
            public void MigrateToSecondsPrecision()
            {
                try
                {
                    // 如果新字段为空但旧字段有数据，进行迁移
                    if (TotalUsageSeconds == 0 && TotalUsageMinutes > 0)
                    {
                        TotalUsageSeconds = TotalUsageMinutes * 60;
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 迁移总使用时长: {TotalUsageMinutes}分钟 -> {TotalUsageSeconds}秒");
                    }

                    if (AverageSessionSeconds == 0 && AverageSessionMinutes > 0)
                    {
                        AverageSessionSeconds = AverageSessionMinutes * 60;
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 迁移平均会话时长: {AverageSessionMinutes}分钟 -> {AverageSessionSeconds}秒");
                    }

                    if (WeeklyUsageSeconds == 0 && WeeklyUsageMinutes > 0)
                    {
                        WeeklyUsageSeconds = WeeklyUsageMinutes * 60;
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 迁移每周使用时长: {WeeklyUsageMinutes}分钟 -> {WeeklyUsageSeconds}秒");
                    }

                    if (LastWeekUsageSeconds == 0 && LastWeekUsageMinutes > 0)
                    {
                        LastWeekUsageSeconds = LastWeekUsageMinutes * 60;
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 迁移上周使用时长: {LastWeekUsageMinutes}分钟 -> {LastWeekUsageSeconds}秒");
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogToFile($"DeviceIdentifier | 数据迁移失败: {ex.Message}", LogHelper.LogType.Error);
                }
            }

            /// <summary>
            /// 检查并重置每周统计数据（秒级精度）
            /// </summary>
            public void CheckAndResetWeeklyStats()
            {
                var now = DateTime.Now;
                var currentWeekStart = GetWeekStartDate(now);

                // 如果是新的一周，重置统计
                if (WeekStartDate == DateTime.MinValue || currentWeekStart > WeekStartDate)
                {
                    // 保存上周数据
                    LastWeekLaunchCount = WeeklyLaunchCount;
                    LastWeekUsageSeconds = WeeklyUsageSeconds;

                    // 同时更新旧字段以保持兼容性
                    LastWeekUsageMinutes = LastWeekUsageSeconds / 60;

                    // 重置本周数据
                    WeeklyLaunchCount = 0;
                    WeeklyUsageSeconds = 0;
                    WeeklyUsageMinutes = 0;
                    WeekStartDate = currentWeekStart;

                    LogHelper.WriteLogToFile($"DeviceIdentifier | 每周统计重置 - 上周启动: {LastWeekLaunchCount}次, 上周使用: {FormatDuration(LastWeekUsageSeconds)}");
                }
            }

            /// <summary>
            /// 获取指定日期所在周的开始日期（周一）
            /// </summary>
            public DateTime GetWeekStartDate(DateTime date)
            {
                var dayOfWeek = (int)date.DayOfWeek;
                var daysToSubtract = dayOfWeek == 0 ? 6 : dayOfWeek - 1; // 周日=0，需要减6天到周一
                return date.Date.AddDays(-daysToSubtract);
            }

            /// <summary>
            /// 记录本周的启动
            /// </summary>
            public void RecordWeeklyLaunch()
            {
                CheckAndResetWeeklyStats();
                WeeklyLaunchCount++;
            }

            /// <summary>
            /// 记录本周的使用时长（秒级精度）
            /// </summary>
            public void RecordWeeklyUsage(long seconds)
            {
                CheckAndResetWeeklyStats();
                WeeklyUsageSeconds += seconds;
                // 同时更新旧字段以保持兼容性
                WeeklyUsageMinutes = WeeklyUsageSeconds / 60;
            }



            /// <summary>
            /// 计算数据哈希值用于完整性验证（秒级精度）
            /// </summary>
            public void UpdateDataHash()
            {
                // 使用秒级精度数据计算哈希
                var dataString = $"{DeviceId}|{LaunchCount}|{TotalUsageSeconds}|{LastLaunchTime:yyyyMMddHHmmss}|{WeeklyLaunchCount}|{WeeklyUsageSeconds}|{DataIntegrityKey}";
                using (var sha256 = SHA256.Create())
                {
                    var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(dataString));
                    DataHash = Convert.ToBase64String(hashBytes);
                }
                LastModified = DateTime.Now;
            }

            /// <summary>
            /// 验证数据完整性（秒级精度）
            /// </summary>
            public bool VerifyDataIntegrity()
            {
                try
                {
                    // 首先尝试使用秒级精度验证
                    var dataString = $"{DeviceId}|{LaunchCount}|{TotalUsageSeconds}|{LastLaunchTime:yyyyMMddHHmmss}|{WeeklyLaunchCount}|{WeeklyUsageSeconds}|{DataIntegrityKey}";
                    using (var sha256 = SHA256.Create())
                    {
                        var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(dataString));
                        var expectedHash = Convert.ToBase64String(hashBytes);
                        if (DataHash == expectedHash)
                        {
                            return true;
                        }
                    }

                    // 如果秒级精度验证失败，尝试使用旧的分钟精度验证（向后兼容）
                    var oldDataString = $"{DeviceId}|{LaunchCount}|{TotalUsageMinutes}|{LastLaunchTime:yyyyMMddHHmmss}|{WeeklyLaunchCount}|{WeeklyUsageMinutes}|{DataIntegrityKey}";
                    using (var sha256 = SHA256.Create())
                    {
                        var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(oldDataString));
                        var expectedHash = Convert.ToBase64String(hashBytes);
                        return DataHash == expectedHash;
                    }
                }
                catch
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 格式化时长显示（秒级精度）
        /// </summary>
        /// <param name="totalSeconds">总秒数</param>
        /// <returns>格式化的时长字符串</returns>
        public static string FormatDuration(long totalSeconds)
        {
            if (totalSeconds < 60)
            {
                return $"{totalSeconds}秒";
            }

            if (totalSeconds < 3600)
            {
                var minutes = totalSeconds / 60;
                var seconds = totalSeconds % 60;
                return seconds > 0 ? $"{minutes}分{seconds}秒" : $"{minutes}分钟";
            }
            else
            {
                var hours = totalSeconds / 3600;
                var minutes = (totalSeconds % 3600) / 60;
                var seconds = totalSeconds % 60;

                var result = $"{hours}小时";
                if (minutes > 0) result += $"{minutes}分";
                if (seconds > 0) result += $"{seconds}秒";

                return result;
            }
        }

        /// <summary>
        /// 更新推送优先级枚举
        /// </summary>
        public enum UpdatePriority
        {
            High = 1,    // 高优先级：立即推送更新
            Medium = 2,  // 中优先级：延迟1-3天推送
            Low = 3      // 低优先级：延迟3-14天推送
        }

        /// <summary>
        /// 用户使用频率分类枚举
        /// </summary>
        public enum UsageFrequency
        {
            High = 1,    // 高频用户：综合评分≥80分（活跃度高、使用时长长、启动频繁）
            Medium = 2,  // 中频用户：综合评分40-79分（中等活跃度和使用强度）
            Low = 3      // 低频用户：综合评分<40分（活跃度低、使用时长短、启动较少）
        }

        /// <summary>
        /// 记录应用启动
        /// </summary>
        public static void RecordAppLaunch()
        {
            try
            {
                lock (fileLock)
                {
                    var stats = LoadUsageStats();
                    stats.LastLaunchTime = DateTime.Now;
                    stats.LaunchCount++;
                    stats.DeviceId = DeviceId;

                    // 记录每周启动次数
                    stats.RecordWeeklyLaunch();

                    // 计算使用频率
                    CalculateUsageFrequency(stats);

                    // 更新数据完整性哈希
                    stats.UpdateDataHash();

                    SaveUsageStats(stats);

                    LogHelper.WriteLogToFile($"DeviceIdentifier | 记录应用启动 - 设备ID: {DeviceId}, 总启动: {stats.LaunchCount}次, 本周启动: {stats.WeeklyLaunchCount}次");
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 记录应用启动失败: {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 记录应用退出（计算使用时长 - 秒级精度）
        /// </summary>
        public static void RecordAppExit()
        {
            try
            {
                lock (fileLock)
                {
                    var stats = LoadUsageStats();

                    // 执行数据迁移（如果需要）
                    stats.MigrateToSecondsPrecision();

                    // 计算本次会话时长（秒级精度）
                    long sessionSeconds = 0;
                    if (stats.LastLaunchTime != DateTime.MinValue)
                    {
                        var sessionDuration = DateTime.Now - stats.LastLaunchTime;
                        sessionSeconds = (long)sessionDuration.TotalSeconds;

                        // 更新秒级精度数据
                        stats.TotalUsageSeconds += sessionSeconds;

                        // 同时更新旧字段以保持兼容性
                        stats.TotalUsageMinutes = stats.TotalUsageSeconds / 60;

                        // 记录每周使用时长（秒级精度）
                        stats.RecordWeeklyUsage(sessionSeconds);

                        // 更新平均会话时长（秒级精度）
                        if (stats.LaunchCount > 0)
                        {
                            stats.AverageSessionSeconds = (double)stats.TotalUsageSeconds / stats.LaunchCount;
                            // 同时更新旧字段以保持兼容性
                            stats.AverageSessionMinutes = stats.AverageSessionSeconds / 60;
                        }
                    }

                    // 重新计算使用频率
                    CalculateUsageFrequency(stats);

                    // 更新数据完整性哈希
                    stats.UpdateDataHash();

                    SaveUsageStats(stats);

                    LogHelper.WriteLogToFile($"DeviceIdentifier | 记录应用退出 - 本次会话: {FormatDuration(sessionSeconds)}, " +
                                           $"总时长: {FormatDuration(stats.TotalUsageSeconds)}, " +
                                           $"本周时长: {FormatDuration(stats.WeeklyUsageSeconds)}");
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 记录应用退出失败: {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 计算使用频率和更新优先级（基于真实的每周统计数据）
        /// 通过多维度评分系统确定用户类型：高频(≥80分)、中频(40-79分)、低频(<40分)
        /// </summary>
        private static void CalculateUsageFrequency(UsageStats stats)
        {
            try
            {
                // 确保每周统计数据是最新的
                stats.CheckAndResetWeeklyStats();

                // 计算最近活跃度
                var daysSinceLastUse = (DateTime.Now - stats.LastLaunchTime).TotalDays;

                // 使用真实的每周数据（秒级精度）
                var currentWeekLaunches = stats.WeeklyLaunchCount;
                var currentWeekSeconds = stats.WeeklyUsageSeconds;

                // 如果秒级数据为空但分钟数据存在，进行转换
                if (currentWeekSeconds == 0 && stats.WeeklyUsageMinutes > 0)
                {
                    currentWeekSeconds = stats.WeeklyUsageMinutes * 60;
                }

                // 如果本周数据不足，参考上周数据
                var weeklyLaunches = currentWeekLaunches > 0 ? currentWeekLaunches : stats.LastWeekLaunchCount;
                var weeklySeconds = currentWeekSeconds > 0 ? currentWeekSeconds : stats.LastWeekUsageSeconds;

                // 如果秒级数据仍为空，使用分钟数据转换
                if (weeklySeconds == 0 && stats.LastWeekUsageMinutes > 0)
                {
                    weeklySeconds = stats.LastWeekUsageMinutes * 60;
                }

                // 综合评分系统（0-100分）
                var frequencyScore = CalculateFrequencyScoreWithWeeklyData(stats, daysSinceLastUse, weeklyLaunches, weeklySeconds);

                // 根据综合评分确定频率分类和更新优先级
                if (frequencyScore >= 80)
                {
                    stats.UsageFrequency = UsageFrequency.High;      // 高频用户：立即推送更新
                    stats.UpdatePriority = UpdatePriority.High;
                }
                else if (frequencyScore >= 40)
                {
                    stats.UsageFrequency = UsageFrequency.Medium;    // 中频用户：延迟1-3天推送
                    stats.UpdatePriority = UpdatePriority.Medium;
                }
                else
                {
                    stats.UsageFrequency = UsageFrequency.Low;       // 低频用户：延迟3-14天推送
                    stats.UpdatePriority = UpdatePriority.Low;
                }

                LogHelper.WriteLogToFile($"DeviceIdentifier | 使用频率计算 - 评分: {frequencyScore}, 频率: {stats.UsageFrequency}, " +
                                       $"优先级: {stats.UpdatePriority}, 本周启动: {currentWeekLaunches}次, 本周时长: {FormatDuration(currentWeekSeconds)}");
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 计算使用频率失败: {ex.Message}", LogHelper.LogType.Error);
                // 默认设置为中等频率和优先级
                stats.UsageFrequency = UsageFrequency.Medium;
                stats.UpdatePriority = UpdatePriority.Medium;
            }
        }

        /// <summary>
        /// 基于每周真实数据计算综合频率评分（0-100分，秒级精度）
        /// 评分标准：≥80分=高频用户，40-79分=中频用户，<40分=低频用户
        /// </summary>
        /// <param name="stats">使用统计数据</param>
        /// <param name="daysSinceLastUse">距离最后使用的天数</param>
        /// <param name="weeklyLaunches">每周启动次数</param>
        /// <param name="weeklySeconds">每周使用时长（秒）</param>
        /// <returns>综合评分（0-100分）</returns>
        private static int CalculateFrequencyScoreWithWeeklyData(UsageStats stats, double daysSinceLastUse,
            long weeklyLaunches, long weeklySeconds)
        {
            var score = 0;

            // 最近活跃度评分（40分）- 反映用户当前的活跃程度
            if (daysSinceLastUse <= 1) score += 40;        // 1天内使用：非常活跃
            else if (daysSinceLastUse <= 3) score += 35;   // 3天内使用：很活跃
            else if (daysSinceLastUse <= 7) score += 25;   // 1周内使用：较活跃
            else if (daysSinceLastUse <= 14) score += 15;  // 2周内使用：一般活跃
            else if (daysSinceLastUse <= 30) score += 5;   // 1月内使用：不太活跃

            // 每周使用频率评分（30分）- 基于真实的每周启动次数
            if (weeklyLaunches >= 10) score += 30;         // 10次以上：高频使用
            else if (weeklyLaunches >= 5) score += 20;     // 5-9次：中高频使用
            else if (weeklyLaunches >= 3) score += 15;     // 3-4次：中频使用
            else if (weeklyLaunches >= 1) score += 10;     // 1-2次：低频使用

            // 每周使用时长评分（20分）- 基于真实的每周使用时长（秒级精度）
            if (weeklySeconds >= 36000) score += 20;         // 10小时以上：重度使用
            else if (weeklySeconds >= 18000) score += 15;    // 5-10小时：中重度使用
            else if (weeklySeconds >= 7200) score += 10;     // 2-5小时：中度使用
            else if (weeklySeconds >= 3600) score += 5;      // 1-2小时：轻度使用

            // 历史使用深度评分（10分）- 反映用户的长期使用习惯（秒级精度）
            var totalSeconds = stats.TotalUsageSeconds > 0 ? stats.TotalUsageSeconds : stats.TotalUsageMinutes * 60;
            if (totalSeconds >= 180000) score += 10;    // 50小时以上：资深用户
            else if (totalSeconds >= 72000) score += 7; // 20-50小时：中等用户
            else if (totalSeconds >= 18000) score += 4;  // 5-20小时：新手用户

            return Math.Min(100, score);
        }



        /// <summary>
        /// 获取当前更新优先级
        /// </summary>
        public static UpdatePriority GetUpdatePriority()
        {
            try
            {
                var stats = LoadUsageStats();
                return stats.UpdatePriority;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 获取更新优先级失败: {ex.Message}", LogHelper.LogType.Error);
                return UpdatePriority.Medium; // 默认中等优先级
            }
        }

        /// <summary>
        /// 获取使用频率
        /// </summary>
        public static UsageFrequency GetUsageFrequency()
        {
            try
            {
                var stats = LoadUsageStats();
                return stats.UsageFrequency;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 获取使用频率失败: {ex.Message}", LogHelper.LogType.Error);
                return UsageFrequency.Medium; // 默认中等频率
            }
        }

        /// <summary>
        /// 获取使用统计信息（秒级精度）
        /// </summary>
        public static (int launchCount, long totalSeconds, double avgSessionSeconds, UpdatePriority priority) GetUsageStats()
        {
            try
            {
                var stats = LoadUsageStats();
                return (stats.LaunchCount, stats.TotalUsageSeconds, stats.AverageSessionSeconds, stats.UpdatePriority);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 获取使用统计失败: {ex.Message}", LogHelper.LogType.Error);
                return (0, 0, 0, UpdatePriority.Medium);
            }
        }

        /// <summary>
        /// 获取使用统计信息（兼容性方法 - 分钟精度）
        /// </summary>
        [Obsolete("请使用 GetUsageStats() 获取秒级精度数据")]
        public static (int launchCount, long totalMinutes, double avgSessionMinutes, UpdatePriority priority) GetUsageStatsInMinutes()
        {
            try
            {
                var stats = LoadUsageStats();
                var totalMinutes = stats.TotalUsageSeconds / 60;
                var avgMinutes = stats.AverageSessionSeconds / 60;
                return (stats.LaunchCount, totalMinutes, avgMinutes, stats.UpdatePriority);
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 获取使用统计失败: {ex.Message}", LogHelper.LogType.Error);
                return (0, 0, 0, UpdatePriority.Medium);
            }
        }

        /// <summary>
        /// 加载使用统计 - 支持多重备份恢复和智能反篡改
        /// </summary>
        private static UsageStats LoadUsageStats()
        {
            try
            {
                // 智能恢复：收集所有可用的数据源，选择最可信的
                var allDataSources = CollectAllUsageDataSources();

                // 如果找到有效数据，返回最可信的
                if (allDataSources.Count > 0)
                {
                    var bestData = SelectMostTrustedData(allDataSources);
                    if (bestData != null)
                    {
                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 使用最可信数据源恢复使用统计: {bestData.Source}");

                        // 执行数据迁移（如果需要）
                        bestData.Stats.MigrateToSecondsPrecision();

                        // 确保备份同步
                        SaveUsageStatsToAllLocations(bestData.Stats);
                        return bestData.Stats;
                    }
                }

                // LogHelper.WriteLogToFile("DeviceIdentifier | 所有数据源都不可用，检查是否有部分可恢复数据", LogHelper.LogType.Warning);

                // 如果没有完全可信的数据，尝试从部分损坏的数据中恢复
                var partiallyRecoveredData = AttemptPartialDataRecovery(allDataSources);
                if (partiallyRecoveredData != null)
                {
                    // LogHelper.WriteLogToFile("DeviceIdentifier | 从部分损坏数据中恢复使用统计");

                    // 执行数据迁移（如果需要）
                    partiallyRecoveredData.MigrateToSecondsPrecision();

                    SaveUsageStatsToAllLocations(partiallyRecoveredData);
                    return partiallyRecoveredData;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 加载使用统计失败: {ex.Message}", LogHelper.LogType.Error);
            }

            // 返回新的统计对象（秒级精度）
            var newStats = new UsageStats
            {
                DeviceId = DeviceId,
                LastLaunchTime = DateTime.Now,
                LaunchCount = 0,
                TotalUsageSeconds = 0,
                AverageSessionSeconds = 0,
                TotalUsageMinutes = 0, // 保持兼容性
                AverageSessionMinutes = 0, // 保持兼容性
                LastUpdateCheck = DateTime.MinValue,
                UpdatePriority = UpdatePriority.Medium,
                UsageFrequency = UsageFrequency.Medium
            };

            // 更新数据完整性哈希
            newStats.UpdateDataHash();

            // 保存新统计到所有位置
            SaveUsageStatsToAllLocations(newStats);
            return newStats;
        }

        /// <summary>
        /// 保存使用统计 - 多重备份
        /// </summary>
        private static void SaveUsageStats(UsageStats stats)
        {
            SaveUsageStatsToAllLocations(stats);
        }

        /// <summary>
        /// 数据源信息结构
        /// </summary>
        private class DataSourceInfo
        {
            public UsageStats Stats { get; set; }
            public string Source { get; set; }
            public bool IsIntegrityValid { get; set; }
            public DateTime LastModified { get; set; }
            public int TrustScore { get; set; }
        }

        /// <summary>
        /// 从文件加载使用统计（带完整性验证，但不丢弃篡改数据）
        /// </summary>
        private static UsageStats LoadUsageStatsFromFile(string filePath)
        {
            try
            {
                if (File.Exists(filePath))
                {
                    string json = File.ReadAllText(filePath);
                    var stats = JsonConvert.DeserializeObject<UsageStats>(json);
                    if (stats != null && !string.IsNullOrEmpty(stats.DeviceId))
                    {
                        // 验证数据完整性
                        if (!string.IsNullOrEmpty(stats.DataHash))
                        {
                            if (stats.VerifyDataIntegrity())
                            {
                                // LogHelper.WriteLogToFile($"DeviceIdentifier | 数据完整性验证通过: {filePath}");
                                return stats;
                            }

                            // LogHelper.WriteLogToFile($"DeviceIdentifier | 数据完整性验证失败，可能被篡改: {filePath}", LogHelper.LogType.Warning);
                            return null; // 数据被篡改，不使用
                        }

                        // 旧版本数据，没有哈希值，更新哈希后返回
                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 检测到旧版本数据，正在更新完整性哈希: {filePath}");
                        stats.UpdateDataHash();
                        return stats;
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 从文件加载使用统计失败 ({filePath}): {ex.Message}", LogHelper.LogType.Error);
            }
            return null;
        }

        /// <summary>
        /// 从文件加载使用统计（包括被篡改的数据，用于恢复分析）
        /// </summary>
        private static DataSourceInfo LoadUsageStatsFromFileWithInfo(string filePath, string sourceName)
        {
            try
            {
                if (File.Exists(filePath))
                {
                    string json = File.ReadAllText(filePath);
                    var stats = JsonConvert.DeserializeObject<UsageStats>(json);
                    if (stats != null && !string.IsNullOrEmpty(stats.DeviceId))
                    {
                        var fileInfo = new FileInfo(filePath);
                        var dataSource = new DataSourceInfo
                        {
                            Stats = stats,
                            Source = sourceName,
                            LastModified = stats.LastModified != DateTime.MinValue ? stats.LastModified : fileInfo.LastWriteTime,
                            IsIntegrityValid = false,
                            TrustScore = 0
                        };

                        // 验证数据完整性
                        if (!string.IsNullOrEmpty(stats.DataHash))
                        {
                            dataSource.IsIntegrityValid = stats.VerifyDataIntegrity();
                            dataSource.TrustScore = dataSource.IsIntegrityValid ? 100 : 20; // 完整数据100分，篡改数据20分
                        }
                        else
                        {
                            // 旧版本数据，中等信任度
                            dataSource.IsIntegrityValid = true;
                            dataSource.TrustScore = 60;
                            stats.UpdateDataHash();
                        }

                        return dataSource;
                    }
                }
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 从文件加载数据源信息失败 ({filePath}): {ex.Message}", LogHelper.LogType.Error);
            }
            return null;
        }

        /// <summary>
        /// 收集所有可用的使用统计数据源
        /// </summary>
        private static List<DataSourceInfo> CollectAllUsageDataSources()
        {
            var dataSources = new List<DataSourceInfo>();

            try
            {
                // 1. 收集文件数据源
                var fileSources = new[]
                {
                    new { Path = UsageStatsFilePath, Name = "主文件" },
                    new { Path = BackupUsageStatsPath, Name = "第一备份" },
                    new { Path = SecondaryUsageBackupPath, Name = "第二备份" },
                    new { Path = TertiaryUsageBackupPath, Name = "第三备份" },
                    new { Path = QuaternaryUsageBackupPath, Name = "第四备份" }
                };

                foreach (var source in fileSources)
                {
                    var dataSource = LoadUsageStatsFromFileWithInfo(source.Path, source.Name);
                    if (dataSource != null)
                    {
                        dataSources.Add(dataSource);
                    }
                }

                // 2. 收集注册表数据源
                var registrySource = LoadUsageStatsFromRegistryWithInfo(@"Software\ICC\DeviceInfo", "主注册表");
                if (registrySource != null)
                {
                    dataSources.Add(registrySource);
                }

                // 3. 收集备用注册表数据源
                var backupRegistryPaths = new[]
                {
                    new { Path = @"Software\Microsoft\Windows\CurrentVersion\ICC", Name = "备用注册表1" },
                    new { Path = @"Software\Classes\.icc\UsageData", Name = "备用注册表2" },
                    new { Path = @"Software\ICC\Config\Usage", Name = "备用注册表3" }
                };

                foreach (var regPath in backupRegistryPaths)
                {
                    var regSource = LoadUsageStatsFromBackupRegistryWithInfo(regPath.Path, regPath.Name);
                    if (regSource != null)
                    {
                        dataSources.Add(regSource);
                    }
                }

                // LogHelper.WriteLogToFile($"DeviceIdentifier | 收集到 {dataSources.Count} 个数据源");
                return dataSources;
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 收集数据源失败: {ex.Message}", LogHelper.LogType.Error);
                return dataSources;
            }
        }

        /// <summary>
        /// 选择最可信的数据源
        /// </summary>
        private static DataSourceInfo SelectMostTrustedData(List<DataSourceInfo> dataSources)
        {
            try
            {
                // 首先尝试找到完整性验证通过的数据
                var validSources = dataSources.Where(d => d.IsIntegrityValid).ToList();

                if (validSources.Count > 0)
                {
                    // 在有效数据中选择最新的
                    var bestValid = validSources.OrderByDescending(d => d.LastModified).First();
                    // LogHelper.WriteLogToFile($"DeviceIdentifier | 选择完整性验证通过的最新数据: {bestValid.Source}");
                    return bestValid;
                }

                // 如果没有完整性验证通过的数据，选择信任度最高的
                var bestByTrust = dataSources.OrderByDescending(d => d.TrustScore).ThenByDescending(d => d.LastModified).FirstOrDefault();
                if (bestByTrust != null)
                {
                    // LogHelper.WriteLogToFile($"DeviceIdentifier | 选择信任度最高的数据: {bestByTrust.Source} (信任度: {bestByTrust.TrustScore})", LogHelper.LogType.Warning);
                    return bestByTrust;
                }

                return null;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 选择最可信数据失败: {ex.Message}", LogHelper.LogType.Error);
                return null;
            }
        }

        /// <summary>
        /// 尝试从部分损坏的数据中恢复
        /// </summary>
        private static UsageStats AttemptPartialDataRecovery(List<DataSourceInfo> dataSources)
        {
            try
            {
                if (dataSources.Count == 0)
                {
                    // LogHelper.WriteLogToFile("DeviceIdentifier | 没有可用数据源进行部分恢复");
                    return null;
                }

                // 从所有数据源中提取可信的字段
                var recoveredStats = new UsageStats
                {
                    DeviceId = DeviceId,
                    LastLaunchTime = DateTime.Now,
                    LaunchCount = 0,
                    TotalUsageMinutes = 0,
                    AverageSessionMinutes = 0,
                    LastUpdateCheck = DateTime.MinValue,
                    UpdatePriority = UpdatePriority.Medium,
                    UsageFrequency = UsageFrequency.Medium
                };

                // 使用多数投票或最大值策略恢复关键数据（秒级精度）
                var launchCounts = dataSources.Where(d => d.Stats.LaunchCount > 0).Select(d => d.Stats.LaunchCount).ToList();
                var usageSeconds = dataSources.Where(d => d.Stats.TotalUsageSeconds > 0).Select(d => d.Stats.TotalUsageSeconds).ToList();
                var usageMinutes = dataSources.Where(d => d.Stats.TotalUsageMinutes > 0).Select(d => d.Stats.TotalUsageMinutes).ToList();

                if (launchCounts.Count > 0)
                {
                    recoveredStats.LaunchCount = (int)launchCounts.Average(); // 使用平均值
                }

                // 优先使用秒级数据，如果没有则使用分钟数据转换
                if (usageSeconds.Count > 0)
                {
                    recoveredStats.TotalUsageSeconds = (long)usageSeconds.Average(); // 使用平均值
                    recoveredStats.TotalUsageMinutes = recoveredStats.TotalUsageSeconds / 60; // 兼容性
                }
                else if (usageMinutes.Count > 0)
                {
                    recoveredStats.TotalUsageMinutes = (long)usageMinutes.Average(); // 使用平均值
                    recoveredStats.TotalUsageSeconds = recoveredStats.TotalUsageMinutes * 60; // 转换为秒
                }

                // 重新计算平均会话时长（秒级精度）
                if (recoveredStats.LaunchCount > 0)
                {
                    recoveredStats.AverageSessionSeconds = (double)recoveredStats.TotalUsageSeconds / recoveredStats.LaunchCount;
                    recoveredStats.AverageSessionMinutes = recoveredStats.AverageSessionSeconds / 60; // 兼容性
                }

                // 重新计算使用频率
                CalculateUsageFrequency(recoveredStats);

                // 更新数据完整性哈希
                recoveredStats.UpdateDataHash();

                // LogHelper.WriteLogToFile($"DeviceIdentifier | 部分数据恢复完成 - 启动次数: {recoveredStats.LaunchCount}, 使用时长: {FormatDuration(recoveredStats.TotalUsageSeconds)}");
                return recoveredStats;
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 部分数据恢复失败: {ex.Message}", LogHelper.LogType.Error);
                return null;
            }
        }

        /// <summary>
        /// 从注册表加载使用统计（带数据源信息）
        /// </summary>
        private static DataSourceInfo LoadUsageStatsFromRegistryWithInfo(string registryPath, string sourceName)
        {
            try
            {
                using (var key = Registry.CurrentUser.OpenSubKey(registryPath))
                {
                    if (key != null)
                    {
                        var deviceId = key.GetValue("DeviceId") as string;
                        var launchCount = key.GetValue("LaunchCount");

                        // 秒级精度数据
                        var totalSeconds = key.GetValue("TotalUsageSeconds");
                        var avgSessionSeconds = key.GetValue("AverageSessionSeconds");

                        // 兼容性：分钟精度数据
                        var totalMinutes = key.GetValue("TotalUsageMinutes");
                        var avgSessionMinutes = key.GetValue("AverageSessionMinutes");

                        var lastLaunch = key.GetValue("LastLaunchTime") as string;
                        var priority = key.GetValue("UpdatePriority");
                        var frequency = key.GetValue("UsageFrequency");
                        var dataHash = key.GetValue("DataHash") as string;
                        var lastUpdate = key.GetValue("LastUpdate") as string;

                        // 每周统计数据（秒级精度）
                        var weeklyLaunchCount = key.GetValue("WeeklyLaunchCount");
                        var weeklyUsageSeconds = key.GetValue("WeeklyUsageSeconds");
                        var lastWeekUsageSeconds = key.GetValue("LastWeekUsageSeconds");

                        // 兼容性：分钟精度数据
                        var weeklyUsageMinutes = key.GetValue("WeeklyUsageMinutes");
                        var lastWeekUsageMinutes = key.GetValue("LastWeekUsageMinutes");

                        var weekStartDate = key.GetValue("WeekStartDate") as string;
                        var lastWeekLaunchCount = key.GetValue("LastWeekLaunchCount");

                        if (!string.IsNullOrEmpty(deviceId) && launchCount != null)
                        {
                            var stats = new UsageStats
                            {
                                DeviceId = deviceId,
                                LaunchCount = Convert.ToInt32(launchCount),

                                // 秒级精度数据
                                TotalUsageSeconds = totalSeconds != null ? Convert.ToInt64(totalSeconds) : 0,
                                AverageSessionSeconds = avgSessionSeconds != null ? Convert.ToDouble(avgSessionSeconds) : 0,

                                // 兼容性：分钟精度数据
                                TotalUsageMinutes = totalMinutes != null ? Convert.ToInt64(totalMinutes) : 0,
                                AverageSessionMinutes = avgSessionMinutes != null ? Convert.ToDouble(avgSessionMinutes) : 0,

                                LastLaunchTime = DateTime.TryParse(lastLaunch, out var dt) ? dt : DateTime.Now,
                                UpdatePriority = priority != null ? (UpdatePriority)Convert.ToInt32(priority) : UpdatePriority.Medium,
                                UsageFrequency = frequency != null ? (UsageFrequency)Convert.ToInt32(frequency) : UsageFrequency.Medium,
                                DataHash = dataHash,
                                LastUpdateCheck = DateTime.MinValue,

                                // 每周统计数据（秒级精度）
                                WeeklyLaunchCount = weeklyLaunchCount != null ? Convert.ToInt32(weeklyLaunchCount) : 0,
                                WeeklyUsageSeconds = weeklyUsageSeconds != null ? Convert.ToInt64(weeklyUsageSeconds) : 0,
                                LastWeekUsageSeconds = lastWeekUsageSeconds != null ? Convert.ToInt64(lastWeekUsageSeconds) : 0,

                                // 兼容性：分钟精度数据
                                WeeklyUsageMinutes = weeklyUsageMinutes != null ? Convert.ToInt64(weeklyUsageMinutes) : 0,
                                LastWeekUsageMinutes = lastWeekUsageMinutes != null ? Convert.ToInt64(lastWeekUsageMinutes) : 0,

                                WeekStartDate = DateTime.TryParse(weekStartDate, out var wsd) ? wsd : DateTime.MinValue,
                                LastWeekLaunchCount = lastWeekLaunchCount != null ? Convert.ToInt32(lastWeekLaunchCount) : 0
                            };

                            // 执行数据迁移（如果需要）
                            stats.MigrateToSecondsPrecision();

                            // 重新计算平均会话时长
                            if (stats.LaunchCount > 0 && stats.AverageSessionSeconds == 0)
                            {
                                stats.AverageSessionSeconds = (double)stats.TotalUsageSeconds / stats.LaunchCount;
                                stats.AverageSessionMinutes = stats.AverageSessionSeconds / 60;
                            }

                            var dataSource = new DataSourceInfo
                            {
                                Stats = stats,
                                Source = sourceName,
                                LastModified = DateTime.TryParse(lastUpdate, out var updateTime) ? updateTime : DateTime.Now,
                                IsIntegrityValid = false,
                                TrustScore = 80 // 注册表数据信任度较高
                            };

                            // 验证数据完整性
                            if (!string.IsNullOrEmpty(stats.DataHash))
                            {
                                dataSource.IsIntegrityValid = stats.VerifyDataIntegrity();
                                dataSource.TrustScore = dataSource.IsIntegrityValid ? 100 : 30;
                            }

                            return dataSource;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 从注册表加载数据源信息失败 ({registryPath}): {ex.Message}", LogHelper.LogType.Error);
            }
            return null;
        }

        /// <summary>
        /// 从备用注册表位置加载使用统计（带数据源信息）
        /// </summary>
        private static DataSourceInfo LoadUsageStatsFromBackupRegistryWithInfo(string registryPath, string sourceName)
        {
            try
            {
                using (var key = Registry.CurrentUser.OpenSubKey(registryPath))
                {
                    if (key != null)
                    {
                        var launchCount = key.GetValue("LC");

                        // 秒级精度数据
                        var totalSeconds = key.GetValue("TUS");
                        var avgSessionSeconds = key.GetValue("ASS");

                        // 兼容性：分钟精度数据
                        var totalMinutes = key.GetValue("TUM");
                        var avgSessionMinutes = key.GetValue("ASM");

                        var lastLaunchBinary = key.GetValue("LLT");
                        var priority = key.GetValue("UP");
                        var frequency = key.GetValue("UF");
                        var dataHash = key.GetValue("DH") as string;
                        var lastUpdateBinary = key.GetValue("LU");

                        // 每周统计数据（秒级精度）
                        var weeklyLaunchCount = key.GetValue("WLC");
                        var weeklyUsageSeconds = key.GetValue("WUS");
                        var lastWeekUsageSeconds = key.GetValue("LWUS");

                        // 兼容性：分钟精度数据
                        var weeklyUsageMinutes = key.GetValue("WUM");
                        var lastWeekUsageMinutes = key.GetValue("LWUM");

                        var weekStartDateBinary = key.GetValue("WSD");
                        var lastWeekLaunchCount = key.GetValue("LWLC");

                        if (launchCount != null && (totalSeconds != null || totalMinutes != null))
                        {
                            var stats = new UsageStats
                            {
                                DeviceId = DeviceId,
                                LaunchCount = Convert.ToInt32(launchCount),

                                // 秒级精度数据
                                TotalUsageSeconds = totalSeconds != null ? Convert.ToInt64(totalSeconds) : 0,
                                AverageSessionSeconds = avgSessionSeconds != null ? Convert.ToDouble(avgSessionSeconds) : 0,

                                // 兼容性：分钟精度数据
                                TotalUsageMinutes = totalMinutes != null ? Convert.ToInt64(totalMinutes) : 0,
                                AverageSessionMinutes = avgSessionMinutes != null ? Convert.ToDouble(avgSessionMinutes) : 0,

                                LastLaunchTime = lastLaunchBinary != null ? DateTime.FromBinary(Convert.ToInt64(lastLaunchBinary)) : DateTime.Now,
                                UpdatePriority = priority != null ? (UpdatePriority)Convert.ToInt32(priority) : UpdatePriority.Medium,
                                UsageFrequency = frequency != null ? (UsageFrequency)Convert.ToInt32(frequency) : UsageFrequency.Medium,
                                DataHash = dataHash,
                                LastUpdateCheck = DateTime.MinValue,

                                // 每周统计数据（秒级精度）
                                WeeklyLaunchCount = weeklyLaunchCount != null ? Convert.ToInt32(weeklyLaunchCount) : 0,
                                WeeklyUsageSeconds = weeklyUsageSeconds != null ? Convert.ToInt64(weeklyUsageSeconds) : 0,
                                LastWeekUsageSeconds = lastWeekUsageSeconds != null ? Convert.ToInt64(lastWeekUsageSeconds) : 0,

                                // 兼容性：分钟精度数据
                                WeeklyUsageMinutes = weeklyUsageMinutes != null ? Convert.ToInt64(weeklyUsageMinutes) : 0,
                                LastWeekUsageMinutes = lastWeekUsageMinutes != null ? Convert.ToInt64(lastWeekUsageMinutes) : 0,

                                WeekStartDate = weekStartDateBinary != null ? DateTime.FromBinary(Convert.ToInt64(weekStartDateBinary)) : DateTime.MinValue,
                                LastWeekLaunchCount = lastWeekLaunchCount != null ? Convert.ToInt32(lastWeekLaunchCount) : 0
                            };

                            // 执行数据迁移（如果需要）
                            stats.MigrateToSecondsPrecision();

                            // 重新计算平均会话时长
                            if (stats.LaunchCount > 0 && stats.AverageSessionSeconds == 0)
                            {
                                stats.AverageSessionSeconds = (double)stats.TotalUsageSeconds / stats.LaunchCount;
                                stats.AverageSessionMinutes = stats.AverageSessionSeconds / 60;
                            }

                            var dataSource = new DataSourceInfo
                            {
                                Stats = stats,
                                Source = sourceName,
                                LastModified = lastUpdateBinary != null ? DateTime.FromBinary(Convert.ToInt64(lastUpdateBinary)) : DateTime.Now,
                                IsIntegrityValid = false,
                                TrustScore = 75 // 备用注册表数据信任度中等
                            };

                            // 验证数据完整性
                            if (!string.IsNullOrEmpty(stats.DataHash))
                            {
                                dataSource.IsIntegrityValid = stats.VerifyDataIntegrity();
                                dataSource.TrustScore = dataSource.IsIntegrityValid ? 100 : 25;
                            }

                            return dataSource;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 从备用注册表加载数据源信息失败 ({registryPath}): {ex.Message}", LogHelper.LogType.Error);
            }
            return null;
        }

        /// <summary>
        /// 从注册表加载使用统计（保持向后兼容）
        /// </summary>
        private static UsageStats LoadUsageStatsFromRegistry()
        {
            var dataSource = LoadUsageStatsFromRegistryWithInfo(@"Software\ICC\DeviceInfo", "主注册表");
            return dataSource?.Stats;
        }

        /// <summary>
        /// 从多个注册表位置加载使用统计（强化恢复）
        /// </summary>
        private static UsageStats LoadUsageStatsFromMultipleRegistryLocations()
        {
            var registryPaths = new[]
            {
                @"Software\Microsoft\Windows\CurrentVersion\ICC",
                @"Software\Classes\.icc\UsageData",
                @"Software\ICC\Config\Usage"
            };

            foreach (var path in registryPaths)
            {
                try
                {
                    using (var key = Registry.CurrentUser.OpenSubKey(path))
                    {
                        if (key != null)
                        {
                            var launchCount = key.GetValue("LC");
                            var totalMinutes = key.GetValue("TUM");
                            var lastLaunchBinary = key.GetValue("LLT");
                            var priority = key.GetValue("UP");
                            var frequency = key.GetValue("UF");
                            var dataHash = key.GetValue("DH") as string;

                            if (launchCount != null && totalMinutes != null)
                            {
                                var stats = new UsageStats
                                {
                                    DeviceId = DeviceId,
                                    LaunchCount = Convert.ToInt32(launchCount),
                                    TotalUsageMinutes = Convert.ToInt64(totalMinutes),
                                    LastLaunchTime = lastLaunchBinary != null ? DateTime.FromBinary(Convert.ToInt64(lastLaunchBinary)) : DateTime.Now,
                                    UpdatePriority = priority != null ? (UpdatePriority)Convert.ToInt32(priority) : UpdatePriority.Medium,
                                    UsageFrequency = frequency != null ? (UsageFrequency)Convert.ToInt32(frequency) : UsageFrequency.Medium,
                                    DataHash = dataHash,
                                    AverageSessionMinutes = 0,
                                    LastUpdateCheck = DateTime.MinValue
                                };

                                // 重新计算平均会话时长
                                if (stats.LaunchCount > 0)
                                {
                                    stats.AverageSessionMinutes = (double)stats.TotalUsageMinutes / stats.LaunchCount;
                                }

                                // 验证数据完整性（如果有哈希值）
                                if (!string.IsNullOrEmpty(stats.DataHash))
                                {
                                    if (stats.VerifyDataIntegrity())
                                    {
                                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 从注册表位置恢复数据并验证完整性通过: {path}");
                                        return stats;
                                    }

                                    // LogHelper.WriteLogToFile($"DeviceIdentifier | 注册表位置数据完整性验证失败: {path}", LogHelper.LogType.Warning);
                                }
                                else
                                {
                                    // 没有哈希值的旧数据，更新哈希后返回
                                    stats.UpdateDataHash();
                                    // LogHelper.WriteLogToFile($"DeviceIdentifier | 从注册表位置恢复旧版本数据: {path}");
                                    return stats;
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogToFile($"DeviceIdentifier | 从注册表位置加载失败 ({path}): {ex.Message}", LogHelper.LogType.Error);
                }
            }

            return null;
        }

        /// <summary>
        /// 保存使用统计到所有位置（强化版本 - 多重隐藏备份）
        /// </summary>
        private static void SaveUsageStatsToAllLocations(UsageStats stats)
        {
            // 保存到主文件
            SaveUsageStatsToFile(UsageStatsFilePath, stats);

            // 保存到第一备份文件
            SaveUsageStatsToFile(BackupUsageStatsPath, stats);

            // 保存到多个隐藏备份位置（专门针对使用频率数据保护）
            SaveUsageStatsToFile(SecondaryUsageBackupPath, stats);
            SaveUsageStatsToFile(TertiaryUsageBackupPath, stats);
            SaveUsageStatsToFile(QuaternaryUsageBackupPath, stats);

            // 保存到注册表
            SaveUsageStatsToRegistry(stats);

            // 保存到注册表的多个位置
            SaveUsageStatsToMultipleRegistryLocations(stats);
        }

        /// <summary>
        /// 保存使用统计到文件
        /// </summary>
        private static void SaveUsageStatsToFile(string filePath, UsageStats stats)
        {
            try
            {
                // 确保目录存在
                var directory = Path.GetDirectoryName(filePath);
                if (!Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                    // 设置隐藏属性
                    if (filePath.Contains(".sys"))
                    {
                        var dirInfo = new DirectoryInfo(directory);
                        dirInfo.Attributes |= FileAttributes.Hidden | FileAttributes.System;
                    }
                }

                string json = JsonConvert.SerializeObject(stats, Formatting.Indented);
                File.WriteAllText(filePath, json);

                // 设置文件属性为隐藏和系统文件
                if (filePath.Contains(".sys"))
                {
                    var fileInfo = new FileInfo(filePath);
                    fileInfo.Attributes |= FileAttributes.Hidden | FileAttributes.System;
                }

                // LogHelper.WriteLogToFile($"DeviceIdentifier | 使用统计已保存到: {filePath}");
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 保存使用统计到文件失败 ({filePath}): {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 保存使用统计到注册表
        /// </summary>
        private static void SaveUsageStatsToRegistry(UsageStats stats)
        {
            try
            {
                // LogHelper.WriteLogToFile("DeviceIdentifier | 开始保存使用统计到主注册表位置");

                using (var key = Registry.CurrentUser.CreateSubKey(@"Software\ICC\DeviceInfo"))
                {
                    if (key != null)
                    {
                        key.SetValue("DeviceId", stats.DeviceId);
                        key.SetValue("LaunchCount", stats.LaunchCount);

                        // 秒级精度数据
                        key.SetValue("TotalUsageSeconds", stats.TotalUsageSeconds);
                        key.SetValue("AverageSessionSeconds", stats.AverageSessionSeconds);

                        // 兼容性：分钟精度数据
                        key.SetValue("TotalUsageMinutes", stats.TotalUsageMinutes);
                        key.SetValue("AverageSessionMinutes", stats.AverageSessionMinutes);

                        key.SetValue("LastLaunchTime", stats.LastLaunchTime.ToString("yyyy-MM-dd HH:mm:ss"));
                        key.SetValue("UpdatePriority", (int)stats.UpdatePriority);
                        key.SetValue("UsageFrequency", (int)stats.UsageFrequency);
                        key.SetValue("DataHash", stats.DataHash ?? "");
                        key.SetValue("LastUpdate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));

                        // 每周统计数据（秒级精度）
                        key.SetValue("WeeklyLaunchCount", stats.WeeklyLaunchCount);
                        key.SetValue("WeeklyUsageSeconds", stats.WeeklyUsageSeconds);
                        key.SetValue("LastWeekUsageSeconds", stats.LastWeekUsageSeconds);

                        // 兼容性：分钟精度数据
                        key.SetValue("WeeklyUsageMinutes", stats.WeeklyUsageMinutes);
                        key.SetValue("LastWeekUsageMinutes", stats.LastWeekUsageMinutes);

                        key.SetValue("WeekStartDate", stats.WeekStartDate.ToString("yyyy-MM-dd"));
                        key.SetValue("LastWeekLaunchCount", stats.LastWeekLaunchCount);

                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 使用统计已保存到主注册表 - 总启动: {stats.LaunchCount}次, 本周启动: {stats.WeeklyLaunchCount}次, " +
                        //                        $"总时长: {FormatDuration(stats.TotalUsageSeconds)}, 本周时长: {FormatDuration(stats.WeeklyUsageSeconds)}");
                    }
                    else
                    {
                        // LogHelper.WriteLogToFile("DeviceIdentifier | 创建主注册表键失败", LogHelper.LogType.Error);
                    }
                }
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 保存使用统计到主注册表失败: {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 保存使用统计到多个注册表位置（强化保护）
        /// </summary>
        private static void SaveUsageStatsToMultipleRegistryLocations(UsageStats stats)
        {
            var registryPaths = new[]
            {
                @"Software\Microsoft\Windows\CurrentVersion\ICC",
                @"Software\Classes\.icc\UsageData",
                @"Software\ICC\Config\Usage"
            };

            // LogHelper.WriteLogToFile($"DeviceIdentifier | 开始保存使用统计到{registryPaths.Length}个备用注册表位置");
            var successCount = 0;

            foreach (var path in registryPaths)
            {
                try
                {
                    using (var key = Registry.CurrentUser.CreateSubKey(path))
                    {
                        if (key != null)
                        {
                            // 使用编码的键名来隐藏数据（秒级精度）
                            key.SetValue("LC", stats.LaunchCount); // LaunchCount

                            // 秒级精度数据
                            key.SetValue("TUS", stats.TotalUsageSeconds); // TotalUsageSeconds
                            key.SetValue("ASS", stats.AverageSessionSeconds); // AverageSessionSeconds

                            // 兼容性：分钟精度数据
                            key.SetValue("TUM", stats.TotalUsageMinutes); // TotalUsageMinutes
                            key.SetValue("ASM", stats.AverageSessionMinutes); // AverageSessionMinutes

                            key.SetValue("LLT", stats.LastLaunchTime.ToBinary()); // LastLaunchTime
                            key.SetValue("UP", (int)stats.UpdatePriority); // UpdatePriority
                            key.SetValue("UF", (int)stats.UsageFrequency); // UsageFrequency
                            key.SetValue("DH", stats.DataHash ?? ""); // DataHash
                            key.SetValue("LU", DateTime.Now.ToBinary()); // LastUpdate

                            // 每周统计数据（秒级精度）
                            key.SetValue("WLC", stats.WeeklyLaunchCount); // WeeklyLaunchCount
                            key.SetValue("WUS", stats.WeeklyUsageSeconds); // WeeklyUsageSeconds
                            key.SetValue("LWUS", stats.LastWeekUsageSeconds); // LastWeekUsageSeconds

                            // 兼容性：分钟精度数据
                            key.SetValue("WUM", stats.WeeklyUsageMinutes); // WeeklyUsageMinutes
                            key.SetValue("LWUM", stats.LastWeekUsageMinutes); // LastWeekUsageMinutes

                            key.SetValue("WSD", stats.WeekStartDate.ToBinary()); // WeekStartDate
                            key.SetValue("LWLC", stats.LastWeekLaunchCount); // LastWeekLaunchCount

                            successCount++;
                            // LogHelper.WriteLogToFile($"DeviceIdentifier | 成功保存到备用注册表位置: {path}");
                        }
                        else
                        {
                            // LogHelper.WriteLogToFile($"DeviceIdentifier | 创建备用注册表键失败: {path}", LogHelper.LogType.Error);
                        }
                    }
                }
                catch (Exception ex)
                {
                    // LogHelper.WriteLogToFile($"DeviceIdentifier | 保存到备用注册表位置失败 ({path}): {ex.Message}", LogHelper.LogType.Error);
                }
            }

            // LogHelper.WriteLogToFile($"DeviceIdentifier | 备用注册表保存完成: {successCount}/{registryPaths.Length} 成功");
        }

        /// <summary>
        /// 记录更新检查时间（同时执行数据保护检查）
        /// </summary>
        public static void RecordUpdateCheck()
        {
            try
            {
                lock (fileLock)
                {
                    var stats = LoadUsageStats();
                    stats.LastUpdateCheck = DateTime.Now;
                    stats.UpdateDataHash();
                    SaveUsageStats(stats);

                    // 定期执行数据保护检查（每10次更新检查执行一次）
                    if (stats.LaunchCount % 10 == 0)
                    {
                        PerformUsageDataProtectionCheck();
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 记录更新检查失败: {ex.Message}", LogHelper.LogType.Error);
            }
        }

        /// <summary>
        /// 执行使用频率数据保护检查和自动修复
        /// </summary>
        public static bool PerformUsageDataProtectionCheck()
        {
            try
            {
                lock (fileLock)
                {
                    LogHelper.WriteLogToFile("DeviceIdentifier | 开始使用频率数据保护检查");

                    var issues = new List<string>();
                    var repaired = new List<string>();
                    var backupPaths = new[]
                    {
                        new { Path = UsageStatsFilePath, Name = "主文件" },
                        new { Path = BackupUsageStatsPath, Name = "第一备份" },
                        new { Path = SecondaryUsageBackupPath, Name = "第二备份" },
                        new { Path = TertiaryUsageBackupPath, Name = "第三备份" },
                        new { Path = QuaternaryUsageBackupPath, Name = "第四备份" }
                    };

                    // 检查所有备份文件
                    UsageStats validStats = null;
                    var missingFiles = new List<string>();

                    foreach (var backup in backupPaths)
                    {
                        if (!File.Exists(backup.Path))
                        {
                            issues.Add($"{backup.Name}丢失");
                            missingFiles.Add(backup.Path);
                        }
                        else
                        {
                            var stats = LoadUsageStatsFromFile(backup.Path);
                            if (stats != null && stats.VerifyDataIntegrity() && validStats == null)
                            {
                                validStats = stats;
                            }
                        }
                    }

                    // 如果找到有效数据，修复丢失的文件
                    if (validStats != null && missingFiles.Count > 0)
                    {
                        foreach (var missingFile in missingFiles)
                        {
                            SaveUsageStatsToFile(missingFile, validStats);
                            repaired.Add($"恢复文件: {Path.GetFileName(missingFile)}");
                        }
                    }

                    // 检查注册表备份
                    var registryPaths = new[]
                    {
                        @"Software\ICC\DeviceInfo",
                        @"Software\Microsoft\Windows\CurrentVersion\ICC",
                        @"Software\Classes\.icc\UsageData",
                        @"Software\ICC\Config\Usage"
                    };

                    var missingRegistryBackups = 0;
                    foreach (var path in registryPaths)
                    {
                        try
                        {
                            using (var key = Registry.CurrentUser.OpenSubKey(path))
                            {
                                if (key == null) missingRegistryBackups++;
                            }
                        }
                        catch
                        {
                            missingRegistryBackups++;
                        }
                    }

                    if (missingRegistryBackups > 0)
                    {
                        issues.Add($"{missingRegistryBackups}个注册表备份丢失");
                        if (validStats != null)
                        {
                            SaveUsageStatsToMultipleRegistryLocations(validStats);
                            repaired.Add("重建注册表备份");
                        }
                    }

                    // 如果没有找到任何有效数据，尝试从注册表恢复
                    if (validStats == null)
                    {
                        validStats = LoadUsageStatsFromRegistry();
                        if (validStats == null)
                        {
                            validStats = LoadUsageStatsFromMultipleRegistryLocations();
                        }

                        if (validStats != null)
                        {
                            SaveUsageStatsToAllLocations(validStats);
                            repaired.Add("从注册表完全恢复数据");
                        }
                        else
                        {
                            // 最后手段：强制重建
                            ForceRebuildUsageDataBackups();
                            repaired.Add("强制重建所有备份");
                        }
                    }

                    // 记录检查结果
                    if (issues.Count > 0)
                    {
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 使用频率数据保护检查发现问题: {string.Join(", ", issues)}", LogHelper.LogType.Warning);
                    }

                    if (repaired.Count > 0)
                    {
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 使用频率数据保护修复: {string.Join(", ", repaired)}");
                    }

                    var protectionScore = CalculateUsageDataProtectionScore();
                    LogHelper.WriteLogToFile($"DeviceIdentifier | 使用频率数据保护检查完成 - 问题: {issues.Count}, 修复: {repaired.Count}, 保护强度: {protectionScore}/100");

                    return protectionScore >= 80;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 使用频率数据保护检查失败: {ex.Message}", LogHelper.LogType.Error);
                return false;
            }
        }

        /// <summary>
        /// 根据优先级决定是否应该推送更新（仅适用于自动更新，版本修复功能不受影响）
        /// </summary>
        /// <param name="updateVersion">更新版本号</param>
        /// <param name="releaseTime">新版本发布时间</param>
        /// <param name="isAutoUpdate">是否为自动更新检查（默认true，false表示版本修复）</param>
        /// <param name="currentVersionReleaseTime">当前版本发布时间</param>
        /// <returns>是否应该推送更新</returns>
        public static bool ShouldPushUpdate(string updateVersion, DateTime releaseTime, bool isAutoUpdate = true, DateTime? currentVersionReleaseTime = null)
        {
            try
            {
                // 判断更新类型（基于版本号）
                var updateType = DetermineUpdateType(updateVersion);

                // 如果不是自动更新（即版本修复），则应用不同的策略
                if (!isAutoUpdate)
                {
                    // 版本修复：立即允许，不受分级策略影响
                    LogHelper.WriteLogToFile($"DeviceIdentifier | 版本修复 - 版本: {updateVersion}, 类型: {updateType}, 结果: 允许");
                    return true;
                }

                var priority = GetUpdatePriority();
                var frequency = GetUsageFrequency();
                var stats = LoadUsageStats();

                // 计算版本间的时间差
                double daysBetweenVersions;
                if (currentVersionReleaseTime.HasValue)
                {
                    // 使用当前版本发布时间与新版本发布时间的差异
                    daysBetweenVersions = (releaseTime - currentVersionReleaseTime.Value).TotalDays;
                }
                else
                {
                    // 如果没有当前版本发布时间，回退到使用新版本发布时间到现在的天数
                    daysBetweenVersions = (DateTime.Now - releaseTime).TotalDays;
                }

                // 计算最近活跃度（最后一次使用距今的天数）
                var daysSinceLastUse = (DateTime.Now - stats.LastLaunchTime).TotalDays;

                // 综合判断逻辑（仅适用于自动更新）
                var shouldPush = ShouldPushUpdateComprehensive(priority, frequency, daysBetweenVersions, daysSinceLastUse, stats, updateType);

                LogHelper.WriteLogToFile($"DeviceIdentifier | 自动更新推送判断 - 版本: {updateVersion}, 类型: {updateType}, " +
                                       $"优先级: {priority}, 频率: {frequency}, 版本间隔: {daysBetweenVersions:F1}天, " +
                                       $"最后使用: {daysSinceLastUse:F1}天前, 结果: {shouldPush}");

                return shouldPush;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 判断是否推送更新失败: {ex.Message}", LogHelper.LogType.Error);
                return true; // 出错时默认推送
            }
        }

        /// <summary>
        /// 更新类型枚举
        /// </summary>
        private enum UpdateType
        {
            Major,      // 主版本更新 (x.0.0)
            Minor,      // 次版本更新 (x.y.0)
            Patch,      // 补丁更新 (x.y.z)
            Hotfix,     // 热修复更新
            Unknown     // 未知类型
        }

        /// <summary>
        /// 根据版本号判断更新类型
        /// </summary>
        private static UpdateType DetermineUpdateType(string version)
        {
            if (string.IsNullOrEmpty(version)) return UpdateType.Unknown;

            try
            {
                // 移除可能的前缀（如 "v"）
                var cleanVersion = version.TrimStart('v', 'V');

                // 检查是否包含热修复标识
                if (cleanVersion.ToLower().Contains("hotfix") || cleanVersion.ToLower().Contains("fix"))
                {
                    return UpdateType.Hotfix;
                }

                // 解析版本号
                var parts = cleanVersion.Split('.');
                if (parts.Length >= 3)
                {
                    if (int.TryParse(parts[1], out int minor) && int.TryParse(parts[2], out int patch))
                    {
                        if (minor == 0 && patch == 0) return UpdateType.Major;
                        if (patch == 0) return UpdateType.Minor;
                        return UpdateType.Patch;
                    }
                }

                return UpdateType.Unknown;
            }
            catch
            {
                return UpdateType.Unknown;
            }
        }

        /// <summary>
        /// 综合时间和使用频率的自动更新推送判断逻辑（不影响版本修复）
        /// </summary>
        /// <param name="priority">用户更新优先级</param>
        /// <param name="frequency">用户使用频率</param>
        /// <param name="daysBetweenVersions">当前版本与新版本之间的天数差异</param>
        /// <param name="daysSinceLastUse">距离最后使用的天数</param>
        /// <param name="stats">使用统计数据</param>
        /// <param name="updateType">更新类型</param>
        /// <returns>是否应该推送更新</returns>
        private static bool ShouldPushUpdateComprehensive(UpdatePriority priority, UsageFrequency frequency,
            double daysBetweenVersions, double daysSinceLastUse, UsageStats stats, UpdateType updateType)
        {
            // 考虑用户的总体使用模式
            var isHeavyUser = stats.TotalUsageMinutes > 3000; // 超过50小时的重度用户
            var isFrequentUser = stats.LaunchCount > 100; // 启动超过100次的频繁用户

            // 根据更新类型调整推送策略
            var urgencyMultiplier = GetUpdateUrgencyMultiplier(updateType);

            // 如果用户长时间未使用（超过30天），降低推送优先级
            if (daysSinceLastUse > 30)
            {
                // 热修复和重要更新优先推送
                if (updateType == UpdateType.Hotfix)
                {
                    return daysBetweenVersions >= 1; // 热修复版本间隔1天后推送
                }

                // 但如果是重度用户，仍然要适当推送
                var baseDelay = isHeavyUser ? 7 : 14;
                return daysBetweenVersions >= (baseDelay / urgencyMultiplier);
            }

            // 如果用户最近很活跃（3天内使用过）
            if (daysSinceLastUse <= 3)
            {
                // 热修复立即推送给活跃用户
                if (updateType == UpdateType.Hotfix)
                {
                    return true;
                }

                // 结合使用频率和优先级判断
                if (frequency == UsageFrequency.High || isHeavyUser)
                {
                    return daysBetweenVersions >= Math.Max(0, 1 / urgencyMultiplier); // 高频用户优先推送
                }

                switch (priority)
                {
                    case UpdatePriority.High:
                        return daysBetweenVersions >= Math.Max(0, 1 / urgencyMultiplier);

                    case UpdatePriority.Medium:
                        return daysBetweenVersions >= Math.Max(1, 2 / urgencyMultiplier);

                    case UpdatePriority.Low:
                        return daysBetweenVersions >= Math.Max(2, 3 / urgencyMultiplier);
                }
            }

            // 中等活跃度用户（3-14天内使用过）
            if (daysSinceLastUse <= 14)
            {
                // 热修复优先推送
                if (updateType == UpdateType.Hotfix)
                {
                    return daysBetweenVersions >= 1;
                }

                // 频繁用户优先推送
                if (isFrequentUser && frequency == UsageFrequency.High)
                {
                    return daysBetweenVersions >= Math.Max(1, 2 / urgencyMultiplier);
                }

                switch (priority)
                {
                    case UpdatePriority.High:
                        return daysBetweenVersions >= Math.Max(1, 2 / urgencyMultiplier);

                    case UpdatePriority.Medium:
                        return daysBetweenVersions >= Math.Max(2, 4 / urgencyMultiplier);

                    case UpdatePriority.Low:
                        return daysBetweenVersions >= Math.Max(4, 7 / urgencyMultiplier);
                }
            }

            // 较不活跃用户（14-30天内使用过）
            // 对于低频率用户，进一步延迟推送
            var delayMultiplier = frequency == UsageFrequency.Low ? 2 : 1;

            switch (priority)
            {
                case UpdatePriority.High:
                    return daysBetweenVersions >= Math.Max(2, 3 * delayMultiplier / urgencyMultiplier);

                case UpdatePriority.Medium:
                    return daysBetweenVersions >= Math.Max(4, 7 * delayMultiplier / urgencyMultiplier);

                case UpdatePriority.Low:
                    return daysBetweenVersions >= Math.Max(7, 14 * delayMultiplier / urgencyMultiplier);

                default:
                    return daysBetweenVersions >= 7;
            }
        }

        /// <summary>
        /// 根据更新类型获取紧急程度倍数（仅用于自动更新分级）
        /// </summary>
        private static double GetUpdateUrgencyMultiplier(UpdateType updateType)
        {
            switch (updateType)
            {
                case UpdateType.Hotfix:
                    return 3.0;   // 热修复最紧急，3倍速度推送
                case UpdateType.Major:
                    return 0.5;   // 主版本更新较慢推送
                case UpdateType.Minor:
                    return 1.0;   // 次版本正常推送
                case UpdateType.Patch:
                    return 1.5;   // 补丁更新稍快推送
                case UpdateType.Unknown:
                    return 1.0;   // 未知类型正常推送
                default:
                    return 1.0;
            }
        }

        /// <summary>
        /// 检查是否应该进行版本修复（不受分级策略影响）
        /// </summary>
        /// <param name="currentVersion">当前版本</param>
        /// <param name="availableVersion">可用版本</param>
        /// <returns>是否需要版本修复</returns>
        public static bool ShouldPerformVersionFix(string currentVersion, string availableVersion)
        {
            try
            {
                // 版本修复功能不受使用频率分级策略影响，始终允许
                LogHelper.WriteLogToFile($"DeviceIdentifier | 版本修复检查 - 当前版本: {currentVersion}, 可用版本: {availableVersion}, 结果: 允许");
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 版本修复检查失败: {ex.Message}", LogHelper.LogType.Error);
                return true; // 出错时默认允许
            }
        }


        /// <summary>
        /// 获取设备信息摘要（用于调试）
        /// </summary>
        public static string GetDeviceInfoSummary()
        {
            try
            {
                var (launchCount, totalSeconds, avgSessionSeconds, priority) = GetUsageStats();
                var frequency = GetUsageFrequency();
                var stats = LoadUsageStats();
                var daysSinceLastUse = (DateTime.Now - stats.LastLaunchTime).TotalDays;

                return $"设备ID: {DeviceId}\n" +
                       $"启动次数: {launchCount}\n" +
                       $"总使用时长: {FormatDuration(totalSeconds)}\n" +
                       $"平均会话时长: {FormatDuration((long)avgSessionSeconds)}\n" +
                       $"使用频率: {frequency}\n" +
                       $"更新优先级: {priority}\n" +
                       $"最后使用: {daysSinceLastUse:F1}天前\n" +
                       $"用户类型: {GetUserTypeDescription(stats)}";
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogToFile($"DeviceIdentifier | 获取设备信息摘要失败: {ex.Message}", LogHelper.LogType.Error);
                return $"设备ID: {DeviceId}\n获取详细信息失败";
            }
        }

        /// <summary>
        /// 获取用户类型描述
        /// </summary>
        private static string GetUserTypeDescription(UsageStats stats)
        {
            var isHeavyUser = stats.TotalUsageMinutes > 3000;
            var isFrequentUser = stats.LaunchCount > 100;
            var daysSinceLastUse = (DateTime.Now - stats.LastLaunchTime).TotalDays;

            var descriptions = new List<string>();

            if (isHeavyUser) descriptions.Add("重度用户");
            if (isFrequentUser) descriptions.Add("频繁用户");

            if (daysSinceLastUse <= 3) descriptions.Add("高活跃");
            else if (daysSinceLastUse <= 14) descriptions.Add("中活跃");
            else if (daysSinceLastUse <= 30) descriptions.Add("低活跃");
            else descriptions.Add("非活跃");

            return descriptions.Count > 0 ? string.Join(", ", descriptions) : "普通用户";
        }

        /// <summary>
        /// 数据自检和修复
        /// </summary>
        public static bool PerformDataIntegrityCheck()
        {
            try
            {
                lock (fileLock)
                {
                    // LogHelper.WriteLogToFile("DeviceIdentifier | 开始数据完整性检查");

                    var issues = new List<string>();
                    var repaired = new List<string>();

                    // 检查设备ID文件
                    if (!File.Exists(DeviceIdFilePath))
                    {
                        issues.Add("主设备ID文件丢失");
                        if (File.Exists(BackupDeviceIdPath))
                        {
                            var backupId = LoadDeviceIdFromFile(BackupDeviceIdPath);
                            if (!string.IsNullOrEmpty(backupId))
                            {
                                SaveDeviceIdToFile(DeviceIdFilePath, backupId);
                                repaired.Add("从备份恢复主设备ID文件");
                            }
                        }
                    }

                    // 检查备份设备ID文件
                    if (!File.Exists(BackupDeviceIdPath))
                    {
                        issues.Add("备份设备ID文件丢失");
                        var mainId = LoadDeviceIdFromFile(DeviceIdFilePath);
                        if (!string.IsNullOrEmpty(mainId))
                        {
                            SaveDeviceIdToFile(BackupDeviceIdPath, mainId);
                            repaired.Add("重建备份设备ID文件");
                        }
                    }

                    // 检查使用统计文件
                    if (!File.Exists(UsageStatsFilePath))
                    {
                        issues.Add("主使用统计文件丢失");
                        var backupStatsForRestore = LoadUsageStatsFromFile(BackupUsageStatsPath);
                        if (backupStatsForRestore != null)
                        {
                            SaveUsageStatsToFile(UsageStatsFilePath, backupStatsForRestore);
                            repaired.Add("从备份恢复主使用统计文件");
                        }
                    }

                    // 检查备份使用统计文件
                    if (!File.Exists(BackupUsageStatsPath))
                    {
                        issues.Add("备份使用统计文件丢失");
                        var mainStatsForBackup = LoadUsageStatsFromFile(UsageStatsFilePath);
                        if (mainStatsForBackup != null)
                        {
                            SaveUsageStatsToFile(BackupUsageStatsPath, mainStatsForBackup);
                            repaired.Add("重建备份使用统计文件");
                        }
                    }

                    // 验证数据一致性
                    var mainStats = LoadUsageStatsFromFile(UsageStatsFilePath);
                    var backupStats = LoadUsageStatsFromFile(BackupUsageStatsPath);

                    if (mainStats != null && backupStats != null)
                    {
                        if (mainStats.LaunchCount != backupStats.LaunchCount ||
                            mainStats.TotalUsageMinutes != backupStats.TotalUsageMinutes)
                        {
                            issues.Add("主备份数据不一致");
                            // 使用最新的数据
                            var newerStats = mainStats.LastModified > backupStats.LastModified ? mainStats : backupStats;
                            SaveUsageStatsToAllLocations(newerStats);
                            repaired.Add("同步主备份数据");
                        }
                    }

                    // 记录检查结果
                    if (issues.Count > 0)
                    {
                        LogHelper.WriteLogToFile($"DeviceIdentifier | 发现问题: {string.Join(", ", issues)}", LogHelper.LogType.Warning);
                    }

                    if (repaired.Count > 0)
                    {
                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 已修复: {string.Join(", ", repaired)}");
                    }

                    // LogHelper.WriteLogToFile($"DeviceIdentifier | 数据完整性检查完成 - 问题: {issues.Count}, 修复: {repaired.Count}");
                    return issues.Count == 0 || repaired.Count > 0;
                }
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 数据完整性检查失败: {ex.Message}", LogHelper.LogType.Error);
                return false;
            }
        }

        /// <summary>
        /// 获取使用频率数据保护状态摘要（强化版本）
        /// </summary>
        public static string GetUsageDataProtectionSummary()
        {
            try
            {
                var summary = new StringBuilder();
                summary.AppendLine("使用频率数据保护状态摘要:");

                // 检查主要文件
                summary.AppendLine($"主使用统计文件: {(File.Exists(UsageStatsFilePath) ? "✓" : "✗")}");
                summary.AppendLine($"第一备份文件: {(File.Exists(BackupUsageStatsPath) ? "✓" : "✗")}");

                // 检查多重隐藏备份
                summary.AppendLine($"第二备份文件: {(File.Exists(SecondaryUsageBackupPath) ? "✓" : "✗")}");
                summary.AppendLine($"第三备份文件: {(File.Exists(TertiaryUsageBackupPath) ? "✓" : "✗")}");
                summary.AppendLine($"第四备份文件: {(File.Exists(QuaternaryUsageBackupPath) ? "✓" : "✗")}");

                // 检查注册表备份
                var registryBackups = 0;
                var registryPaths = new[]
                {
                    @"Software\ICC\DeviceInfo",
                    @"Software\Microsoft\Windows\CurrentVersion\ICC",
                    @"Software\Classes\.icc\UsageData",
                    @"Software\ICC\Config\Usage"
                };

                foreach (var path in registryPaths)
                {
                    try
                    {
                        using (var key = Registry.CurrentUser.OpenSubKey(path))
                        {
                            if (key != null) registryBackups++;
                        }
                    }
                    catch { }
                }

                summary.AppendLine($"注册表备份位置: {registryBackups}/4 ✓");

                // 检查数据完整性和可恢复性
                var stats = LoadUsageStats();
                if (stats != null)
                {
                    summary.AppendLine($"数据完整性: {(stats.VerifyDataIntegrity() ? "✓" : "✗")}");
                    summary.AppendLine($"总启动次数: {stats.LaunchCount}");
                    summary.AppendLine($"总使用时长: {FormatDuration(stats.TotalUsageSeconds)}");
                    summary.AppendLine($"本周启动次数: {stats.WeeklyLaunchCount}");
                    summary.AppendLine($"本周使用时长: {FormatDuration(stats.WeeklyUsageSeconds)}");
                    summary.AppendLine($"上周启动次数: {stats.LastWeekLaunchCount}");
                    summary.AppendLine($"上周使用时长: {FormatDuration(stats.LastWeekUsageSeconds)}");
                    summary.AppendLine($"本周开始日期: {(stats.WeekStartDate != DateTime.MinValue ? stats.WeekStartDate.ToString("yyyy-MM-dd") : "未设置")}");
                    summary.AppendLine($"使用频率: {stats.UsageFrequency}");
                    summary.AppendLine($"更新优先级: {stats.UpdatePriority}");
                    summary.AppendLine($"最后修改: {stats.LastModified:yyyy-MM-dd HH:mm:ss}");
                }

                // 计算保护强度评分
                var protectionScore = CalculateUsageDataProtectionScore();
                summary.AppendLine($"保护强度评分: {protectionScore}/100");

                return summary.ToString();
            }
            catch (Exception ex)
            {
                return $"获取使用频率数据保护状态失败: {ex.Message}";
            }
        }

        /// <summary>
        /// 计算使用频率数据保护强度评分
        /// </summary>
        private static int CalculateUsageDataProtectionScore()
        {
            var score = 0;

            try
            {
                // 文件备份评分（50分）
                if (File.Exists(UsageStatsFilePath)) score += 15;
                if (File.Exists(BackupUsageStatsPath)) score += 10;
                if (File.Exists(SecondaryUsageBackupPath)) score += 8;
                if (File.Exists(TertiaryUsageBackupPath)) score += 8;
                if (File.Exists(QuaternaryUsageBackupPath)) score += 9;

                // 注册表备份评分（30分）
                var registryPaths = new[]
                {
                    @"Software\ICC\DeviceInfo",
                    @"Software\Microsoft\Windows\CurrentVersion\ICC",
                    @"Software\Classes\.icc\UsageData",
                    @"Software\ICC\Config\Usage"
                };

                foreach (var path in registryPaths)
                {
                    try
                    {
                        using (var key = Registry.CurrentUser.OpenSubKey(path))
                        {
                            if (key != null) score += 7;
                        }
                    }
                    catch { }
                }

                // 数据完整性评分（20分）
                var stats = LoadUsageStats();
                if (stats != null)
                {
                    if (!string.IsNullOrEmpty(stats.DataHash)) score += 10;
                    if (stats.VerifyDataIntegrity()) score += 10;
                }
            }
            catch { }

            return Math.Min(100, score);
        }

        /// <summary>
        /// 强制重建所有使用频率数据备份
        /// </summary>
        public static bool ForceRebuildUsageDataBackups()
        {
            try
            {
                lock (fileLock)
                {
                    // LogHelper.WriteLogToFile("DeviceIdentifier | 开始强制重建使用频率数据备份");

                    var stats = LoadUsageStats();
                    if (stats == null)
                    {
                        // 如果无法加载任何数据，创建基础数据
                        stats = new UsageStats
                        {
                            DeviceId = DeviceId,
                            LastLaunchTime = DateTime.Now,
                            LaunchCount = 1,
                            TotalUsageMinutes = 0,
                            AverageSessionMinutes = 0,
                            LastUpdateCheck = DateTime.MinValue,
                            UpdatePriority = UpdatePriority.Medium,
                            UsageFrequency = UsageFrequency.Medium
                        };
                        stats.UpdateDataHash();
                        LogHelper.WriteLogToFile("DeviceIdentifier | 创建新的基础使用数据");
                    }

                    // 强制保存到所有位置
                    SaveUsageStatsToAllLocations(stats);

                    // 验证重建结果
                    var protectionScore = CalculateUsageDataProtectionScore();
                    // LogHelper.WriteLogToFile($"DeviceIdentifier | 使用频率数据备份重建完成，保护强度: {protectionScore}/100");

                    return protectionScore >= 80; // 80分以上认为重建成功
                }
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 强制重建使用频率数据备份失败: {ex.Message}", LogHelper.LogType.Error);
                return false;
            }
        }

        /// <summary>
        /// 获取数据保护状态摘要（保持向后兼容）
        /// </summary>
        public static string GetDataProtectionSummary()
        {
            return GetUsageDataProtectionSummary();
        }





        /// <summary>
        /// 强制执行一次完整的数据保存操作（包括注册表）
        /// </summary>
        public static bool ForceCompleteDataSave()
        {
            try
            {
                lock (fileLock)
                {
                    // LogHelper.WriteLogToFile("DeviceIdentifier | 开始强制完整数据保存");

                    // 保存设备ID到所有位置
                    SaveDeviceIdToAllLocations(DeviceId);

                    // 加载并保存使用统计到所有位置
                    var stats = LoadUsageStats();
                    if (stats != null)
                    {
                        stats.UpdateDataHash();
                        SaveUsageStatsToAllLocations(stats);

                        // 验证注册表保存是否成功
                        var verificationResult = VerifyRegistryData();
                        // LogHelper.WriteLogToFile($"DeviceIdentifier | 注册表数据验证结果: {verificationResult}");

                        // LogHelper.WriteLogToFile("DeviceIdentifier | 强制完整数据保存完成");
                        return true;
                    }

                    // LogHelper.WriteLogToFile("DeviceIdentifier | 强制完整数据保存失败: 无法加载使用统计", LogHelper.LogType.Error);
                    return false;
                }
            }
            catch (Exception ex)
            {
                // LogHelper.WriteLogToFile($"DeviceIdentifier | 强制完整数据保存失败: {ex.Message}", LogHelper.LogType.Error);
                return false;
            }
        }

        /// <summary>
        /// 验证注册表中的数据是否存在
        /// </summary>
        public static string VerifyRegistryData()
        {
            var results = new StringBuilder();
            results.AppendLine("注册表数据验证结果:");

            try
            {
                // 验证主注册表位置
                try
                {
                    using (var key = Registry.CurrentUser.OpenSubKey(@"Software\ICC\DeviceInfo"))
                    {
                        if (key != null)
                        {
                            var deviceId = key.GetValue("DeviceId") as string;
                            var launchCount = key.GetValue("LaunchCount");
                            var totalMinutes = key.GetValue("TotalUsageMinutes");
                            var lastUpdate = key.GetValue("LastUpdate") as string;

                            results.AppendLine("✓ 主注册表位置存在");
                            results.AppendLine($"  设备ID: {deviceId ?? "未找到"}");
                            results.AppendLine($"  启动次数: {launchCount ?? "未找到"}");
                            results.AppendLine($"  使用时长: {totalMinutes ?? "未找到"}分钟");
                            results.AppendLine($"  最后更新: {lastUpdate ?? "未找到"}");
                        }
                        else
                        {
                            results.AppendLine("✗ 主注册表位置不存在");
                        }
                    }
                }
                catch (Exception ex)
                {
                    results.AppendLine($"✗ 主注册表位置访问失败: {ex.Message}");
                }

                // 验证备用注册表位置
                var registryPaths = new[]
                {
                    @"Software\Microsoft\Windows\CurrentVersion\ICC",
                    @"Software\Classes\.icc\UsageData",
                    @"Software\ICC\Config\Usage"
                };

                foreach (var path in registryPaths)
                {
                    try
                    {
                        using (var key = Registry.CurrentUser.OpenSubKey(path))
                        {
                            if (key != null)
                            {
                                var launchCount = key.GetValue("LC");
                                var totalMinutes = key.GetValue("TUM");
                                var lastUpdate = key.GetValue("LU");

                                results.AppendLine($"✓ 备用注册表位置存在: {path}");
                                results.AppendLine($"  启动次数: {launchCount ?? "未找到"}");
                                results.AppendLine($"  使用时长: {totalMinutes ?? "未找到"}");
                                results.AppendLine($"  最后更新: {(lastUpdate != null ? DateTime.FromBinary(Convert.ToInt64(lastUpdate)).ToString("yyyy-MM-dd HH:mm:ss") : "未找到")}");
                            }
                            else
                            {
                                results.AppendLine($"✗ 备用注册表位置不存在: {path}");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        results.AppendLine($"✗ 备用注册表位置访问失败 ({path}): {ex.Message}");
                    }
                }

                return results.ToString();
            }
            catch (Exception ex)
            {
                return $"注册表数据验证失败: {ex.Message}";
            }
        }

        /// <summary>
        /// 立即执行一次数据保存并验证注册表写入
        /// </summary>
        public static string SaveAndVerifyRegistryData()
        {
            try
            {
                // LogHelper.WriteLogToFile("DeviceIdentifier | 开始保存并验证注册表数据");

                // 强制保存数据
                var saveSuccess = ForceCompleteDataSave();

                // 验证注册表数据
                var verificationResult = VerifyRegistryData();

                var result = $"保存操作: {(saveSuccess ? "成功" : "失败")}\n\n{verificationResult}";

                // LogHelper.WriteLogToFile("DeviceIdentifier | 保存并验证注册表数据完成");
                return result;
            }
            catch (Exception ex)
            {
                var errorMsg = $"保存并验证注册表数据失败: {ex.Message}";
                LogHelper.WriteLogToFile($"DeviceIdentifier | {errorMsg}", LogHelper.LogType.Error);
                return errorMsg;
            }
        }
    }
}