硬件信息收集助手类

/// <summary>
/// 硬件信息收集助手类
/// </summary>
public static class HardwareInfoHelper
{
    /// <summary>
    /// 获取CPU序列号
    /// </summary>
    /// <returns>CPU序列号</returns>
    public static async Task<string> GetCpuSerialNumberAsync()
    {
        return await Task.Run(() =>
        {
            try
            {
                using var searcher = new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor");
                using var collection = searcher.Get();

                foreach (ManagementObject obj in collection)
                {
                    string? processorId = obj["ProcessorId"]?.ToString();
                    if (!string.IsNullOrEmpty(processorId))
                    {
                        return processorId;
                    }
                }
            }
            catch (Exception ex)
            {
                // 记录异常，但不抛出，返回备用值
                Console.WriteLine($"获取CPU序列号失败: {ex.Message}");
            }

            // 如果无法获取CPU序列号，使用机器名作为备用
            return Environment.MachineName;
        });
    }

    /// <summary>
    /// 获取主板序列号
    /// </summary>
    /// <returns>主板序列号</returns>
    public static async Task<string> GetMotherboardSerialNumberAsync()
    {
        return await Task.Run(() =>
        {
            try
            {
                using var searcher = new ManagementObjectSearcher("SELECT SerialNumber FROM Win32_BaseBoard");
                using var collection = searcher.Get();

                foreach (ManagementObject obj in collection)
                {
                    string? serialNumber = obj["SerialNumber"]?.ToString();
                    if (!string.IsNullOrEmpty(serialNumber) && serialNumber != "None")
                    {
                        return serialNumber;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取主板序列号失败: {ex.Message}");
            }

            return "UNKNOWN_MOTHERBOARD";
        });
    }

    /// <summary>
    /// 获取硬盘序列号
    /// </summary>
    /// <returns>硬盘序列号</returns>
    public static async Task<string> GetHardDiskSerialNumberAsync()
    {
        return await Task.Run(() =>
        {
            try
            {
                using var searcher = new ManagementObjectSearcher("SELECT SerialNumber FROM Win32_PhysicalMedia");
                using var collection = searcher.Get();

                foreach (ManagementObject obj in collection)
                {
                    string? serialNumber = obj["SerialNumber"]?.ToString()?.Trim();
                    if (!string.IsNullOrEmpty(serialNumber))
                    {
                        return serialNumber;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取硬盘序列号失败: {ex.Message}");
            }

            return "UNKNOWN_HARDDISK";
        });
    }

    /// <summary>
    /// 获取网卡MAC地址
    /// </summary>
    /// <returns>MAC地址</returns>
    public static async Task<string> GetMacAddressAsync()
    {
        return await Task.Run(() =>
        {
            try
            {
                NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();

                // 优先获取以太网适配器的MAC地址
                NetworkInterface? ethernetAdapter = networkInterfaces
                    .Where(nic => nic.NetworkInterfaceType == NetworkInterfaceType.Ethernet &&
                                 nic.OperationalStatus == OperationalStatus.Up)
                    .FirstOrDefault();

                if (ethernetAdapter != null)
                {
                    return ethernetAdapter.GetPhysicalAddress().ToString();
                }

                // 如果没有以太网适配器，获取第一个可用的网络适配器
                NetworkInterface? firstAdapter = networkInterfaces
                    .Where(nic => nic.OperationalStatus == OperationalStatus.Up &&
                                 !string.IsNullOrEmpty(nic.GetPhysicalAddress().ToString()) &&
                                 nic.NetworkInterfaceType != NetworkInterfaceType.Loopback)
                    .FirstOrDefault();

                if (firstAdapter != null)
                {
                    return firstAdapter.GetPhysicalAddress().ToString();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取MAC地址失败: {ex.Message}");
            }

            return "UNKNOWN_MAC";
        });
    }

    /// <summary>
    /// 获取操作系统信息
    /// </summary>
    /// <returns>操作系统信息</returns>
    public static async Task<string> GetOperatingSystemInfoAsync()
    {
        return await Task.Run(() =>
        {
            try
            {
                using var searcher = new ManagementObjectSearcher("SELECT Caption, Version, OSArchitecture FROM Win32_OperatingSystem");
                using var collection = searcher.Get();

                foreach (ManagementObject obj in collection)
                {
                    string? caption = obj["Caption"]?.ToString();
                    string? version = obj["Version"]?.ToString();
                    string? architecture = obj["OSArchitecture"]?.ToString();

                    return $"{caption} {version} ({architecture})";
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"获取操作系统信息失败: {ex.Message}");
            }

            // 备用方案：使用Environment类获取基本信息
            return $"{Environment.OSVersion} ({Environment.Is64BitOperatingSystem})";
        });
    }

    /// <summary>
    /// 获取完整的硬件信息摘要
    /// </summary>
    /// <returns>硬件信息字符串</returns>
    public static async Task<string> GetHardwareInfoSummaryAsync()
    {
        string cpu = await GetCpuSerialNumberAsync();
        string motherboard = await GetMotherboardSerialNumberAsync();
        string harddisk = await GetHardDiskSerialNumberAsync();
        string mac = await GetMacAddressAsync();
        string os = await GetOperatingSystemInfoAsync();

        return $"CPU:{cpu}|MB:{motherboard}|HDD:{harddisk}|MAC:{mac}|OS:{os}";
    }

    /// <summary>
    /// 获取硬件信息对象
    /// </summary>
    /// <returns>硬件信息对象</returns>
    public static async Task<Workon.Win.AuthorizationTool.Common.Models.HardwareInfo> GetHardwareInfoAsync()
    {
        var hardwareInfo = new Workon.Win.AuthorizationTool.Common.Models.HardwareInfo
        {
            CpuId = await GetCpuSerialNumberAsync(),
            MotherboardSerialNumber = await GetMotherboardSerialNumberAsync(),
            HardDiskSerialNumber = await GetHardDiskSerialNumberAsync(),
            MacAddress = await GetMacAddressAsync(),
            OperatingSystem = await GetOperatingSystemInfoAsync(),
            CollectedAt = DateTime.Now
        };

        // 尝试获取更多详细信息
        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT Name, NumberOfCores FROM Win32_Processor");
            using var collection = searcher.Get();
            foreach (ManagementObject obj in collection)
            {
                hardwareInfo.ProcessorName = obj["Name"]?.ToString() ?? string.Empty;
                hardwareInfo.ProcessorCores = Convert.ToInt32(obj["NumberOfCores"] ?? 0);
                break; // 只取第一个处理器
            }
        }
        catch
        {
            // 忽略错误，使用默认值
        }

        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT Manufacturer, Product FROM Win32_BaseBoard");
            using var collection = searcher.Get();
            foreach (ManagementObject obj in collection)
            {
                hardwareInfo.MotherboardManufacturer = obj["Manufacturer"]?.ToString() ?? string.Empty;
                hardwareInfo.MotherboardProduct = obj["Product"]?.ToString() ?? string.Empty;
                break;
            }
        }
        catch
        {
            // 忽略错误，使用默认值
        }

        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT TotalVisibleMemorySize FROM Win32_OperatingSystem");
            using var collection = searcher.Get();
            foreach (ManagementObject obj in collection)
            {
                hardwareInfo.TotalMemory = Convert.ToInt64(obj["TotalVisibleMemorySize"] ?? 0);
                break;
            }
        }
        catch
        {
            // 忽略错误，使用默认值
        }

        return hardwareInfo;
    }

    /// <summary>
    /// 生成设备指纹
    /// </summary>
    /// <param name="hardwareInfo">硬件信息</param>
    /// <returns>设备指纹</returns>
    public static async Task<Workon.Win.AuthorizationTool.Common.Models.DeviceFingerprint> GenerateDeviceFingerprintAsync(Workon.Win.AuthorizationTool.Common.Models.HardwareInfo hardwareInfo)
    {
        string combinedData = $"{hardwareInfo.CpuId}|{hardwareInfo.MotherboardSerialNumber}|{hardwareInfo.HardDiskSerialNumber}|{hardwareInfo.MacAddress}";
        string hash = await Task.Run(() => CryptographyHelper.ComputeSha256Hash(combinedData));

        return new Workon.Win.AuthorizationTool.Common.Models.DeviceFingerprint
        {
            Hash = hash,
            HardwareInfo = hardwareInfo,
            GeneratedAt = DateTime.Now
        };
    }

    /// <summary>
    /// 获取设备指纹（同步版本）
    /// </summary>
    /// <returns>设备指纹</returns>
    public static string GetDeviceFingerprint()
    {
        try
        {
            // 使用同步方式获取硬件信息，避免死锁
            string cpu = GetCpuSerialNumberSync();
            string motherboard = GetMotherboardSerialNumberSync();
            string harddisk = GetHardDiskSerialNumberSync();
            string mac = GetMacAddressSync();
            string os = GetOperatingSystemInfoSync();

            string summary = $"CPU:{cpu}|MB:{motherboard}|HDD:{harddisk}|MAC:{mac}|OS:{os}";
            return CryptographyHelper.ComputeSha256Hash(summary);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取设备指纹失败: {ex.Message}");
            return "UNKNOWN_DEVICE";
        }
    }

    /// <summary>
    /// 获取CPU序列号（同步版本）
    /// </summary>
    /// <returns>CPU序列号</returns>
    private static string GetCpuSerialNumberSync()
    {
        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor");
            using var collection = searcher.Get();

            foreach (ManagementObject obj in collection)
            {
                string? processorId = obj["ProcessorId"]?.ToString();
                if (!string.IsNullOrEmpty(processorId))
                {
                    return processorId;
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取CPU序列号失败: {ex.Message}");
        }

        return Environment.MachineName;
    }

    /// <summary>
    /// 获取主板序列号（同步版本）
    /// </summary>
    /// <returns>主板序列号</returns>
    private static string GetMotherboardSerialNumberSync()
    {
        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT SerialNumber FROM Win32_BaseBoard");
            using var collection = searcher.Get();

            foreach (ManagementObject obj in collection)
            {
                string? serialNumber = obj["SerialNumber"]?.ToString();
                if (!string.IsNullOrEmpty(serialNumber) && serialNumber != "None")
                {
                    return serialNumber;
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取主板序列号失败: {ex.Message}");
        }

        return "UNKNOWN_MOTHERBOARD";
    }

    /// <summary>
    /// 获取硬盘序列号（同步版本）
    /// </summary>
    /// <returns>硬盘序列号</returns>
    private static string GetHardDiskSerialNumberSync()
    {
        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT SerialNumber FROM Win32_PhysicalMedia");
            using var collection = searcher.Get();

            foreach (ManagementObject obj in collection)
            {
                string? serialNumber = obj["SerialNumber"]?.ToString()?.Trim();
                if (!string.IsNullOrEmpty(serialNumber))
                {
                    return serialNumber;
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取硬盘序列号失败: {ex.Message}");
        }

        return "UNKNOWN_HARDDISK";
    }

    /// <summary>
    /// 获取网卡MAC地址（同步版本）
    /// </summary>
    /// <returns>MAC地址</returns>
    private static string GetMacAddressSync()
    {
        try
        {
            NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();

            // 优先获取以太网适配器的MAC地址
            NetworkInterface? ethernetAdapter = networkInterfaces
                .Where(nic => nic.NetworkInterfaceType == NetworkInterfaceType.Ethernet &&
                             nic.OperationalStatus == OperationalStatus.Up)
                .FirstOrDefault();

            if (ethernetAdapter != null)
            {
                return ethernetAdapter.GetPhysicalAddress().ToString();
            }

            // 如果没有以太网适配器，获取第一个可用的网络适配器
            NetworkInterface? firstAdapter = networkInterfaces
                .Where(nic => nic.OperationalStatus == OperationalStatus.Up &&
                             !string.IsNullOrEmpty(nic.GetPhysicalAddress().ToString()) &&
                             nic.NetworkInterfaceType != NetworkInterfaceType.Loopback)
                .FirstOrDefault();

            if (firstAdapter != null)
            {
                return firstAdapter.GetPhysicalAddress().ToString();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取MAC地址失败: {ex.Message}");
        }

        return "UNKNOWN_MAC";
    }

    /// <summary>
    /// 获取操作系统信息（同步版本）
    /// </summary>
    /// <returns>操作系统信息</returns>
    private static string GetOperatingSystemInfoSync()
    {
        try
        {
            using var searcher = new ManagementObjectSearcher("SELECT Caption, Version, OSArchitecture FROM Win32_OperatingSystem");
            using var collection = searcher.Get();

            foreach (ManagementObject obj in collection)
            {
                string? caption = obj["Caption"]?.ToString();
                string? version = obj["Version"]?.ToString();
                string? architecture = obj["OSArchitecture"]?.ToString();

                return $"{caption} {version} ({architecture})";
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取操作系统信息失败: {ex.Message}");
        }

        // 备用方案：使用Environment类获取基本信息
        return $"{Environment.OSVersion} ({Environment.Is64BitOperatingSystem})";
    }

    /// <summary>
    /// 获取机器指纹
    /// </summary>
    /// <returns>机器指纹字符串</returns>
    public static async Task<string> GetMachineFingerprint()
    {
        try
        {
            string cpu = await GetCpuSerialNumberAsync();
            string motherboard = await GetMotherboardSerialNumberAsync();
            string harddisk = await GetHardDiskSerialNumberAsync();
            string mac = await GetMacAddressAsync();

            // 组合关键硬件信息生成指纹
            string combinedInfo = $"{cpu}{motherboard}{harddisk}{mac}";
            
            // 使用SHA256生成哈希值作为指纹
            using var sha256 = System.Security.Cryptography.SHA256.Create();
            byte[] hashBytes = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(combinedInfo));
            return Convert.ToBase64String(hashBytes);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取机器指纹失败: {ex.Message}");
            // 返回一个基于机器名和时间的备用指纹
            return Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{Environment.MachineName}{DateTime.Now:yyyyMMdd}"));
        }
    }

    /// <summary>
    /// 获取硬件指纹信息
    /// </summary>
    /// <returns>硬件指纹对象</returns>
    public static DeviceFingerprint GetHardwareFingerprint()
    {
        try
        {
            // 使用同步方法获取基本硬件信息并生成组合指纹
            string cpu = GetCpuSerialNumberSync();
            string motherboard = GetMotherboardSerialNumberSync();
            string harddisk = GetHardDiskSerialNumberSync();
            string mac = GetMacAddressSync();
            string os = GetOperatingSystemInfoSync();
            
            string combinedInfo = $"{cpu}|{motherboard}|{harddisk}|{mac}|{os}";
            string hash = HashHelper.ComputeStringHash(combinedInfo, "SHA-256").HashHex;
            
            return new DeviceFingerprint
            {
                CombinedFingerprint = hash,
                Fingerprint = hash,
                Algorithm = "SHA256",
                GeneratedAt = DateTime.Now,
                RawData = combinedInfo
            };
        }
        catch (Exception ex)
        {
            Console.WriteLine($"获取硬件指纹失败: {ex.Message}");
            // 发生错误时返回基于机器名的备用指纹
            string fallbackData = Environment.MachineName + Environment.UserName;
            string fallbackHash = HashHelper.ComputeStringHash(fallbackData, "SHA-256").HashHex;
            
            return new DeviceFingerprint
            {
                CombinedFingerprint = fallbackHash,
                Fingerprint = fallbackHash,
                Algorithm = "SHA256",
                GeneratedAt = DateTime.Now,
                RawData = fallbackData
            };
        }
    }
}

/// <summary>
/// 设备指纹类（为了支持CombinedFingerprint属性）
/// </summary>
public class DeviceFingerprint
{
    /// <summary>
    /// 组合指纹（向后兼容属性）
    /// </summary>
    public string CombinedFingerprint { get; set; } = string.Empty;

    /// <summary>
    /// 设备指纹字符串
    /// </summary>
    public string Fingerprint { get; set; } = string.Empty;

    /// <summary>
    /// 生成算法
    /// </summary>
    public string Algorithm { get; set; } = "SHA256";

    /// <summary>
    /// 生成时间
    /// </summary>
    public DateTime GeneratedAt { get; set; } = DateTime.Now;

    /// <summary>
    /// 原始数据
    /// </summary>
    public string RawData { get; set; } = string.Empty;
}