#pragma once

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <string.h>
#include <sstream>
#include <memory>
#include <stdexcept>
#include <array>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <unordered_map>
#include <functional>

// CPU信息結構體
struct CPUInfo
{
    std::string processor_;              // CPU 的邏輯編號
    std::string vendor_id_;              // CPU 制造商的標識符
    std::string cpu_family_;             // CPU 所屬的家族編號
    std::string model_;                  // CPU 型號編號
    std::string model_name_;             // CPU 的完整型號名稱
    std::string stepping_;               // CPU 的步進編號
    std::string microcode_;              // CPU 微代碼版本號
    std::string cpu_freq_;               // CPU 當前的運行頻率，單位為 MHz
    std::string cache_size_;             // CPU 緩存的大小，單位為KB
    std::string physical_id_;            // CPU 的標識符
    std::string siblings_;               // 同一物理 CPU 上的邏輯處理器數(shù)量
    std::string core_id_;                // 每個物理核心的唯一標識符
    std::string cpu_cores_;              // 每個物理 CPU 中的核心數(shù)量，不包括超線程產(chǎn)生的邏輯核心
    std::string clflush_size_;           // 緩存行刷新（Cache Line Flush）操作所涉及的緩存行大小
};

// 磁盤信息結構體
struct DiskStatsInfo
{
    std::string major_device_num_;          // 主設備號，標識設備類型
    std::string minor_device_num_;          // 次設備號，用于在同一主設備類型下進一步區(qū)分具體的設備實例，主設備號和次設備號共同唯一標識系統(tǒng)中的一個塊設備
    std::string device_name_;               // 磁盤名稱，對應/dev目錄下的設備文件名
    std::string read_completed_;            // 從設備成功完成的讀操作次數(shù)，每次成功讀取數(shù)據(jù)塊，該計數(shù)增加
    std::string read_merged_;               // 合并讀操作次數(shù)
    std::string read_sectors_;              // 從設備讀取的扇區(qū)總數(shù)
    std::string read_time_spent_;           // 累計花費在讀操作上的時間，單位毫秒
    std::string write_completed_;           // 向設備成功完成的寫操作次數(shù)，每次成功寫入數(shù)據(jù)塊，該計數(shù)增加
    std::string write_merged_;              // 合并寫操作次數(shù)
    std::string write_sectors_;             // 向設備寫入的扇區(qū)總數(shù)
    std::string write_time_spent_;          // 累計花費在寫操作上的時間，單位毫秒
};

// BIOS信息結構體，細節(jié)信息通過dmidecode命令獲取到的
struct BIOSMoreInfo
{
    // 基礎信息
    std::string     vendor_;                    // BIOS供應商
    std::string     version_;                   // BIOS版本
    std::string     date_;                      // BIOS發(fā)布日期
    
    // 細節(jié)信息
    std::string   address_;                     // BIOS 在內(nèi)存中的物理地址(十六進制)
    std::string   runtime_size_;                // BIOS運行時占用的內(nèi)存大小，單位為bytes
    std::string   rom_size_;                    // 存儲 BIOS 固件的 ROM（只讀存儲器）容量，單位為kB
    std::string   bios_revision_;               // BIOS的修訂版本號，可能與Version不同
    std::string   firmware_revisioin_;          // 主板固件版本號
};

// 主板信息結構體，細節(jié)信息通過dmidecode命令獲取
struct BaseboardMoreInfo
{
    // 基礎信息
    std::string     vendor_;                    // 主板供應商
    std::string     version_;                   // 主板版本號
    std::string     name_;                      // 主板型號
    std::string     asset_tag_;                 // 主板資產(chǎn)標簽

    // 細節(jié)信息
    std::string     serial_num_;                // 主板序列號
    std::string     location_in_chassis_;       // 主板在機箱中的位置
    std::string     type_;                      // 主板類型
};

// 檢測當前運行環(huán)境是否可以使用dmidecode命令
#ifndef IsUseDmidecodeCommand
#define IsUseDmidecodeCommand()\
    bool is_use_dmidecode = false;\
    \
    if(geteuid() == 0 && FindDmidecodePath())\
        is_use_dmidecode = true;\
    else\
        std::cout << "當前運行環(huán)境不支持dmidecode命令, 只獲取基本信息" << std::endl;
#endif

// 根據(jù):進行字符串切割并去除兩端空格得到key和value字符串
#ifndef SplitRemoveWhite
#define SplitRemoveWhite(_line)\
    size_t pos = _line.find(':');\
    \
    if (pos == std::string::npos)\
        return;\
    \
    std::string key = _line.substr(0, pos);\
    std::string value = _line.substr(pos + 1);\
    \
    RemoveWhiteSpace(value);\
    RemoveWhiteSpace(key);
#endif

// Linux下獲取CPU的所有信息
class LinuxHardwareInfo
{
public:

    LinuxHardwareInfo();
    ~LinuxHardwareInfo();

    /*
        @brief 獲取CPU的所有信息
        @param _cpu_infos 會有多個cpu的信息
    */
    void GetProcessorAllInfo(std::vector<CPUInfo>& _cpu_infos);

    /*
        @brief 獲取磁盤的所有信息
        @param _disk_infos 會有多個磁盤信息
    */
    void GetDiskStatsAllInfo(std::vector<DiskStatsInfo>& _disk_infos);

    /*
        @brief 獲取BIOS的信息
            1、該接口會先使用demidecode命令獲取BIOS更詳細的信息，如果檢測到系統(tǒng)的demidecode命令無法使用，改用讀取文件的方式只獲取BISO
                基本信息?。。?
            2、該接口返回true的情況為：Linux系統(tǒng)已經(jīng)安裝demidecode命令，并且運行程序的用戶為root用戶
        @param _bios_info BIOS信息結構體
        @return true表示demidecode命令可以使用，獲取到了更詳細的信息；false說明當前運行環(huán)境的demidecode命令無法使用，只能獲取基本信息。
    */
    bool GetBIOSAllInfo(BIOSMoreInfo& _bios_info);

    /*
        @brief 獲取主板的信息
            1、該接口會先使用demidecode命令獲取BIOS更詳細的信息，如果檢測到系統(tǒng)的demidecode命令無法使用，改用讀取文件的方式只獲取主板
                基本信息?。?！
            2、該接口返回true的情況為：Linux系統(tǒng)已經(jīng)安裝demidecode命令，并且運行程序的用戶為root用戶
        @param _board_info 主板信息結構體
        @return true表示demidecode命令可以使用，獲取到了更詳細的信息；false說明當前運行環(huán)境的demidecode命令無法使用，只能獲取基本信息。
    */
    bool GetBoardAllInfo(BaseboardMoreInfo& _board_info);

private:

    /*
        @brief 通過讀取文件的方式獲取BIOS基本信息
        @param BIOS基本信息
    */
    void GetBIOSBasicInfo(BIOSMoreInfo& _bios_info);

    /*
        @brief 通過讀取文件的方式獲取主板基本信息
        @param 主板基本信息
    */
    void GetBoardBasicInfo(BaseboardMoreInfo& _board_info);

    /*
        @brief 去除字符串兩端的空白字符，包括空格、\t等
        @param _str 源字符串
    */
    void RemoveWhiteSpace(std::string& _str);

    /*
        @brief 解析CPU文件信息的一行
        @param _line 一行字符串
        @param _cpu_info 存儲數(shù)據(jù)的結構體
    */
    void ParseProcessorLine(const std::string& _line, CPUInfo& _cpu_info);

    /*
        @brief 處理BISO信息的一行
        @param _line 一行字符串
        @param _bios_info BISO數(shù)據(jù)結構體
    */
    void ProcessBIOSLine(const std::string& _line, BIOSMoreInfo& _bios_info);

    /*
        @brief 處理主板信息的一行
        @param _line 一行字符串
        @param _board_info 主板數(shù)據(jù)結構體
    */
    void ProcessBoardLine(const std::string& _line, BaseboardMoreInfo& _board_info);

    /*
        @brief 檢查 dmidecode 是否存在并返回其完整路徑
        @return true表示存在，false表示不存在
    */
    bool FindDmidecodePath();

    /*
        @brief 執(zhí)行命令并捕獲輸出
        @param cmd 命令
        @return 輸出的字符串
    */
    std::string GetStrByCommand(const char* _cmd);

    /*
        @brief 按照換行符進行切割
        @param _str 源字符串
        @return 切割后的集合
    */
    std::vector<std::string> SplitByNewline(const std::string& _str);

    /*
        @brief 更新主板結構體處理器
        @param _key 結構體成員對應的key值
        @param value 結構體成員值
    */
    void UpdateBoardInfo(BaseboardMoreInfo& _board_info, const std::string& _key, const std::string& _value);

    /*
        @brief 更新BIOS結構體處理器
        @param _key 結構體成員對應的key值
        @param value 結構體成員值
    */
    void UpdateBIOSInfo(BIOSMoreInfo& _bios_info, const std::string& _key, const std::string& _value);

    /*
        @brief 更新CPU結構體處理器
        @param _key 結構體成員對應的key值
        @param value 結構體成員值
    */
    void UpdateCpuInfo(CPUInfo& _cpu_info, const std::string& _key, const std::string& _value);

private:

    // 成員指針類型別名
    using BoardMemberPtr = std::string BaseboardMoreInfo::*;

    using BIOSMemberPtr = std::string BIOSMoreInfo::*;

    using CpuMemberPtr = std::string CPUInfo::*;

    const std::string cpu_file_;        // Linux系統(tǒng)下cpu信息的存儲路徑

    const std::string disk_file_;       // Linux系統(tǒng)下磁盤信息的存儲路徑

    const std::string bios_dir_;                             // Linux系統(tǒng)下存放BIOS信息的目錄
    const std::vector<std::string>  bios_files_name_;        // Linux系統(tǒng)下存放BIOS信息的所有文件名

    const std::string board_dir_;                             // Linux系統(tǒng)下存放主板信息的目錄
    const std::vector<std::string>  board_files_name_;        // Linux系統(tǒng)下存放主板信息的所有文件名

    const std::vector<std::string>  dmidecode_command_path_; // Linux系統(tǒng)下常見的demidecode命令的完整路徑，檢測系統(tǒng)是否安裝該命令會用到

    std::unordered_map<std::string, std::function<void(std::string)>>   process_board_value_map_;           // 給主板信息結構體賦值    
};

#include "LinuxHardwareInfo.h"

LinuxHardwareInfo::LinuxHardwareInfo()
    : cpu_file_("/proc/cpuinfo")
    , disk_file_("/proc/diskstats")
    , bios_dir_("/sys/class/dmi/id/")
    , bios_files_name_({"bios_vendor","bios_version","bios_date"})
    , dmidecode_command_path_({"/usr/sbin/dmidecode", "/sbin/dmidecode", "/usr/local/sbin/dmidecode"})
    , board_dir_("/sys/class/dmi/id/")
    , board_files_name_({"board_vendor","board_version","board_name","board_asset_tag"})
{
}

LinuxHardwareInfo::~LinuxHardwareInfo()
{
}

void LinuxHardwareInfo::GetProcessorAllInfo(std::vector<CPUInfo> &_cpu_info)
{
    std::ifstream file(cpu_file_);
    
    if (!file.is_open())
    {
        std::cerr << "CPU文件: " << cpu_file_ << "打開失敗" << std::endl;

        return;
    }

    CPUInfo cpuInfo;
    std::string line;
    while (std::getline(file, line))
    {
        if (line.empty())
        {
            // 讀取下一個cpu的信息
            if(!cpuInfo.model_name_.empty()) 
            {
                _cpu_info.push_back(cpuInfo);
                cpuInfo = CPUInfo();
            }
        }
        else
            ParseProcessorLine(line, cpuInfo);
    }

    // 添加最后一個CPU信息
    if (!cpuInfo.model_name_.empty()) 
    {
        _cpu_info.push_back(cpuInfo);
    }

    file.close();
}

void LinuxHardwareInfo::GetDiskStatsAllInfo(std::vector<DiskStatsInfo> &_disk_infos)
{
    std::ifstream disk_stats_file(disk_file_);
    if (!disk_stats_file.is_open()) 
    {
        std::cerr << "磁盤文件: " << disk_file_ << "打開失敗" << std::endl;
     
        return;
    }

    std::string line;
    while (std::getline(disk_stats_file, line))
    {
        std::istringstream iss(line);

        DiskStatsInfo diskStats;

        std::string inFlight, ioTicks, timeInQueue;

        if (!(iss >> diskStats.major_device_num_ >> diskStats.minor_device_num_ >> diskStats.device_name_
                  >> diskStats.read_completed_ >> diskStats.read_merged_ >> diskStats.read_sectors_
                  >> diskStats.read_time_spent_ >> diskStats.write_completed_ 
                  >> diskStats.write_merged_ >> diskStats.write_sectors_ >> diskStats.write_time_spent_ 
                  >> inFlight >> ioTicks >> timeInQueue)) 
        {
            continue;
        }

        _disk_infos.push_back(diskStats);
    }

    disk_stats_file.close();

    return;
}

bool LinuxHardwareInfo::GetBIOSAllInfo(BIOSMoreInfo &_bios_info)
{
    IsUseDmidecodeCommand()

    if(is_use_dmidecode)   // 使用dmidecode命令獲取更詳細的BISO信息
    {
        try
        {
            // 對獲取到的命令輸出進行字符串切割
            std::vector<std::string> bios_info_vec = SplitByNewline(GetStrByCommand("dmidecode -t bios"));

            for(const auto& line : bios_info_vec)
            {
                ProcessBIOSLine(line, _bios_info);
            }

        } catch (const std::exception& e)
        {
            std::cerr << "dmidecode命令執(zhí)行錯誤: " << e.what() << std::endl;

            // 拋出異常后只獲取基本信息
            GetBIOSBasicInfo(_bios_info);

            return false;
        }
    }
    else    // 只獲取基本信息
        GetBIOSBasicInfo(_bios_info);

    return is_use_dmidecode;
}

bool LinuxHardwareInfo::GetBoardAllInfo(BaseboardMoreInfo &_board_info)
{
    IsUseDmidecodeCommand()

    if(is_use_dmidecode)   // 使用dmidecode命令獲取更詳細的主板信息
    {
        try
        {
            // 對獲取到的命令輸出進行字符串切割
            std::vector<std::string> board_info_vec = SplitByNewline(GetStrByCommand("dmidecode -t baseboard"));

            bool is_parse = false;
            for(const auto& line : board_info_vec)
            {
                if(line == "Base Board Information")
                    is_parse = true;
                else if(line.empty())
                    is_parse = false;
                
                if(is_parse)
                    ProcessBoardLine(line, _board_info);
            }

        } catch (const std::exception& e)
        {
            std::cerr << "dmidecode命令執(zhí)行錯誤: " << e.what() << std::endl;

            // 拋出異常后只獲取基本信息
            GetBoardBasicInfo(_board_info);

            return false;
        }
    }
    else    // 只獲取基本信息
        GetBoardBasicInfo(_board_info);

    return is_use_dmidecode;
}

void LinuxHardwareInfo::GetBIOSBasicInfo(BIOSMoreInfo &_bios_info)
{
    for(const auto& file_name : bios_files_name_)
    {
        // bios文件路徑
        std::string path = bios_dir_ + file_name;
        std::ifstream file(path);
        if (!file.is_open())
        {
            std::cerr << "BIOS文件: " << path << "打開失敗" << std::endl;
            return;
        }

        std::string value;
        std::getline(file, value);
        
        UpdateBIOSInfo(_bios_info,file_name,value);
    }
}

void LinuxHardwareInfo::GetBoardBasicInfo(BaseboardMoreInfo &_board_info)
{
    for(const auto& file_name : board_files_name_)
    {
        // board文件路徑
        std::string path = board_dir_ + file_name;
        std::ifstream file(path);
        if (!file.is_open())
        {
            std::cerr << "主板文件: " << path << "打開失敗" << std::endl;
            return;
        }

        std::string value;
        std::getline(file, value);
        
        UpdateBoardInfo(_board_info,file_name,value);
    }
}

void LinuxHardwareInfo::RemoveWhiteSpace(std::string &_str)
{
    int head_idx = 0, tail_idx = _str.length() - 1;

    bool head_flag = false, tail_flag = false;

    while (head_idx != tail_idx)
    {
        // 使用std::isspace方法判斷空白字符，因為會有\(zhòng)t等情況
        if(!head_flag && std::isspace(_str[head_idx]))
            head_idx++;
        else
            head_flag = true;

        if(!tail_flag && std::isspace(_str[tail_idx]))
            tail_idx--;
        else
            tail_flag = true;

        if(head_flag && tail_flag)
            break;
    }

    _str = _str.substr(head_idx, tail_idx - head_idx + 1);

    return;
}

void LinuxHardwareInfo::ParseProcessorLine(const std::string &_line, CPUInfo &_cpu_info)
{
    SplitRemoveWhite(_line)

    UpdateCpuInfo(_cpu_info,key,value);
}

void LinuxHardwareInfo::ProcessBIOSLine(const std::string &_line, BIOSMoreInfo &_bios_info)
{
    SplitRemoveWhite(_line)

    UpdateBIOSInfo(_bios_info,key,value);
}

void LinuxHardwareInfo::ProcessBoardLine(const std::string &_line, BaseboardMoreInfo &_board_info)
{
    SplitRemoveWhite(_line)

    UpdateBoardInfo(_board_info,key,value);
}

bool LinuxHardwareInfo::FindDmidecodePath()
{
    for (const auto& path : dmidecode_command_path_) 
    {
        if (access(path.c_str(), X_OK) == 0) 
        {
            return true; // 找到有效路徑
        }
    }

    return false;
}

std::string LinuxHardwareInfo::GetStrByCommand(const char *_cmd)
{
    std::array<char, 128> buffer;
    std::string result;
    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(_cmd, "r"), pclose);

    if (!pipe) 
    {
        throw std::runtime_error("Failed to execute command");
    }

    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) 
    {
        result += buffer.data();
    }

    return result;
}

std::vector<std::string> LinuxHardwareInfo::SplitByNewline(const std::string &_str)
{
    std::vector<std::string> lines;
    std::istringstream iss(_str);
    std::string line;   
    
    while (std::getline(iss, line, '\n')) 
    {
        lines.push_back(line);
    }

    return lines;
}

void LinuxHardwareInfo::UpdateBoardInfo(BaseboardMoreInfo &_board_info, const std::string &_key, const std::string &_value)
{
    static const std::unordered_map<std::string, BoardMemberPtr> keys_map = {
        {"Manufacturer",   &BaseboardMoreInfo::vendor_},
        {"Product Name",   &BaseboardMoreInfo::name_},
        {"Version",  &BaseboardMoreInfo::version_},
        {"Serial Number",       &BaseboardMoreInfo::serial_num_},
        {"Asset Tag",  &BaseboardMoreInfo::asset_tag_},
        {"Location In Chassis",    &BaseboardMoreInfo::location_in_chassis_},
        {"Type",    &BaseboardMoreInfo::type_},
        {"board_vendor",   &BaseboardMoreInfo::vendor_},
        {"board_name",   &BaseboardMoreInfo::name_},
        {"board_version",   &BaseboardMoreInfo::version_},
        {"board_asset_tag",   &BaseboardMoreInfo::asset_tag_},
        {"board_serial",   &BaseboardMoreInfo::serial_num_}
    };

    if (auto it = keys_map.find(_key); it != keys_map.end()) 
    {
        _board_info.*(it->second) = _value;
    }
    // else
    //     std::cerr << "解析出" << _key << "和" << _value << std::endl;
}

void LinuxHardwareInfo::UpdateBIOSInfo(BIOSMoreInfo &_bios_info, const std::string &_key, const std::string &_value)
{
    static const std::unordered_map<std::string, BIOSMemberPtr> keys_map = {
        {"Vendor",   &BIOSMoreInfo::vendor_},
        {"Release Date",   &BIOSMoreInfo::date_},
        {"Version",  &BIOSMoreInfo::version_},
        {"Address",       &BIOSMoreInfo::address_},
        {"Runtime Size",  &BIOSMoreInfo::runtime_size_},
        {"ROM Size",    &BIOSMoreInfo::rom_size_},
        {"BIOS Revision",    &BIOSMoreInfo::bios_revision_},
        {"Firmware Revision",    &BIOSMoreInfo::firmware_revisioin_},
        {"bios_vendor",   &BIOSMoreInfo::vendor_},
        {"bios_date",   &BIOSMoreInfo::date_},
        {"bios_version",   &BIOSMoreInfo::version_}
    };

    if (auto it = keys_map.find(_key); it != keys_map.end()) 
    {
        // 部分字段帶有單位，去除單位
        if(_value.find(" ") != std::string::npos)
        {
            size_t pos = _value.find(" ");

            _bios_info.*(it->second) = _value.substr(0, pos);
        }
        else
            _bios_info.*(it->second) = _value;
    }
    // else
    //     std::cerr << "解析出" << _key << "和" << _value << std::endl;
}

void LinuxHardwareInfo::UpdateCpuInfo(CPUInfo& _cpu_info, const std::string &_key, const std::string &_value)
{
    static const std::unordered_map<std::string, CpuMemberPtr> keys_map = {
        {"processor",   &CPUInfo::processor_},
        {"vendor_id",   &CPUInfo::vendor_id_},
        {"cpu family",  &CPUInfo::cpu_family_},
        {"model",       &CPUInfo::model_},
        {"model name",  &CPUInfo::model_name_},
        {"stepping",    &CPUInfo::stepping_},
        {"microcode",    &CPUInfo::microcode_},
        {"cpu MHz",    &CPUInfo::cpu_freq_},
        {"physical id",   &CPUInfo::physical_id_},
        {"siblings",   &CPUInfo::siblings_},
        {"core id",   &CPUInfo::core_id_},
        {"cpu cores",   &CPUInfo::cpu_cores_},
        {"clflush size",   &CPUInfo::clflush_size_}
    };

    if (auto it = keys_map.find(_key); it != keys_map.end()) 
    {
        // 部分字段帶有單位，去除單位
        if(_value.find(" ") != std::string::npos)
        {
            size_t pos = _value.find(" ");

            _cpu_info.*(it->second) = _value.substr(0, pos);
        }
        else
            _cpu_info.*(it->second) = _value;
    }
    // else
    //     std::cerr << "解析出" << _key << "和" << _value << std::endl;
}

#include <iostream>
#include "LinuxHardwareInfo.h"
int main()
{
    LinuxHardwareInfo info;

    std::cout << "*************************CPU信息*************************" << std::endl;

    std::vector<CPUInfo> cpuInfos;
    info.GetProcessorAllInfo(cpuInfos);

    for (const auto& cpuInfo : cpuInfos)
    {
        std::cout << "-------------------------" << std::endl;
        std::cout << "processor: " << cpuInfo.processor_ << std::endl;
        std::cout << "Vendor ID: " << cpuInfo.vendor_id_ << std::endl;
        std::cout << "CPU Family: " << cpuInfo.cpu_family_ << std::endl;
        std::cout << "Model: " << cpuInfo.model_ << std::endl;
        std::cout << "Model Name: " << cpuInfo.model_name_ << std::endl;
        std::cout << "Stepping: " << cpuInfo.stepping_ << std::endl;
        std::cout << "Microcode: " << cpuInfo.microcode_ << std::endl;
        std::cout << "CPU MHz: " << cpuInfo.cpu_freq_ << std::endl;
        std::cout << "Cache Size: " << cpuInfo.cache_size_ << std::endl;
        std::cout << "Physical ID: " << cpuInfo.physical_id_ << std::endl;
        std::cout << "Siblings: " << cpuInfo.siblings_ << std::endl;
        std::cout << "Core ID: " << cpuInfo.core_id_ << std::endl;
        std::cout << "CPU Cores: " << cpuInfo.cpu_cores_ << std::endl;
        std::cout << "clflush size: " << cpuInfo.clflush_size_ << std::endl;
        std::cout << "-------------------------" << std::endl;
    }

    std::cout << "*************************CPU信息*************************" << std::endl;

    std::cout << "*************************磁盤信息*************************" << std::endl;

    std::vector<DiskStatsInfo> disk_infos;
    info.GetDiskStatsAllInfo(disk_infos);

    for (const auto& diskStats : disk_infos) 
    {
        std::cout << "-------------------------" << std::endl;
        std::cout << "主設備號: " << diskStats.major_device_num_ << std::endl;
        std::cout << "次設備號: " << diskStats.minor_device_num_ << std::endl;
        std::cout << "磁盤名稱: " << diskStats.device_name_ << std::endl;
        std::cout << "完成的讀操作次數(shù): " << diskStats.read_completed_ << std::endl;
        std::cout << "合并讀操作次數(shù): " << diskStats.read_merged_ << std::endl;
        std::cout << "讀取的扇區(qū)總數(shù): " << diskStats.read_sectors_ << std::endl;
        std::cout << "花費在讀操作上的時間: " << diskStats.read_time_spent_ << std::endl;
        std::cout << "完成的寫操作次數(shù): " << diskStats.write_completed_ << std::endl;
        std::cout << "合并寫操作次數(shù): " << diskStats.write_merged_ << std::endl;
        std::cout << "寫入的扇區(qū)總數(shù): " << diskStats.write_sectors_ << std::endl;
        std::cout << "花費在寫操作上的時間: " << diskStats.write_time_spent_ << std::endl;
        std::cout << "-------------------------" << std::endl;
    }
    std::cout << "*************************磁盤信息*************************" << std::endl;

    std::cout << "*************************BIOS信息*************************" << std::endl;

    BIOSMoreInfo bios_info;
    info.GetBIOSAllInfo(bios_info);

    std::cout << "BIOS版本號: " << bios_info.version_ << std::endl;
    std::cout << "BIOS供應商: " << bios_info.vendor_ << std::endl;
    std::cout << "BIOS發(fā)布日期: " << bios_info.date_ << std::endl;
    std::cout << "BIOS 在內(nèi)存中的物理地址: " << bios_info.address_ << std::endl;
    std::cout << "BIOS運行時占用的內(nèi)存大小: " << bios_info.runtime_size_ << std::endl;
    std::cout << "存儲BIOS固件的ROM(只讀存儲器)容量: " << bios_info.rom_size_ << std::endl;
    std::cout << "BIOS 的修訂版本號: " << bios_info.bios_revision_ << std::endl;
    std::cout << "主板固件的版本號: " << bios_info.firmware_revisioin_ << std::endl;
    std::cout << "*************************BIOS信息*************************" << std::endl;
 
    std::cout << "*************************主板信息*************************" << std::endl;
 
    BaseboardMoreInfo board_info;
    info.GetBoardAllInfo(board_info);
 
    std::cout << "主板版本號: " << board_info.version_ << std::endl;
    std::cout << "主板供應商: " << board_info.vendor_ << std::endl;
    std::cout << "主板型號: " << board_info.name_ << std::endl;
    std::cout << "主板序列號: " << board_info.serial_num_ << std::endl;
    std::cout << "主板資產(chǎn)標簽: " << board_info.asset_tag_ << std::endl;
    std::cout << "主板在機箱中的位置: " << board_info.location_in_chassis_ << std::endl;
    std::cout << "主板類型: " << board_info.type_ << std::endl;
    std::cout << "*************************主板信息*************************" << std::endl;

    return 0;
}