use crate::prelude::*;

use std::{
    net::{IpAddr,SocketAddr},
};
use serde::{Serialize, Deserialize};
use regex_lite::Regex;
//https://crates.io/crates/sysinfo

use network_interface::{NetworkInterface, NetworkInterfaceConfig, Addr};



#[cfg(all(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
use wallpaper;
use sysinfo::{Disks, Networks, System};
static 全局_SYSTEM: Lazy<Mutex<System>> = Lazy::new(|| Mutex::new(System::new()));
static 全局_DISKS: Lazy<Mutex<Disks>> = Lazy::new(||Mutex::new(Disks::new()));
static 全局_NETWORKS: Lazy<Mutex<Networks>> = Lazy::new(||Mutex::new(Networks::new()));




#[gen_特征_derive(MOD特征_os)]
impl 信令路由{
    async fn exec文本信令_os(&self,函数名:&str, mut 参数数组:Vec<String>)-> anyhow_Result<(bool,Value,Vec<String>)>{
        let 信令路由ref = self;
        let 结果 = match 函数名{
            "home" | "系统_基础目录"=>{ json!(信令路由ref.系统_基础目录().await?)      }
            "os" | "系统_读取系统OS信息" =>{ json!(信令路由ref.系统_读取系统OS信息().await?)   }
            "cpu" | "系统_读取CPU数组" =>{ json!(信令路由ref.系统_读取CPU数组().await?)      }
            "mem" =>{ json!(信令路由ref.系统_读取内存数组().await?)     }
            "disk" | "系统_读取磁盘数组"=>{ json!(信令路由ref.系统_读取磁盘数组().await?)     }
            "net" =>{ json!(信令路由ref.系统_读取网络NET数组().await?)  }
            #[cfg(all(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
            "系统_读取or设置壁纸" => {
                let 壁纸路径 = if 参数数组.len() >= 1 && 参数数组[0]!="null" && 参数数组[0]!="undefined"{ 参数数组.remove(0) }else{ "".to_string() };
                json!(信令路由ref.系统_读取or设置壁纸(壁纸路径).await?)  
            }
            "系统_读取or设置屏幕亮度"=>{
                let 亮度值 = if 参数数组.len() >=2{ if let Ok(num) = 参数数组[1].parse::<f32>(){ Some(num) }else{ None }  }else{ None };
                let 屏幕设备id = if 参数数组.len() >=1 && 参数数组[0]!="null" && 参数数组[0]!="undefined"{   Some(参数数组.remove(0))  }else{ None };
                json!(信令路由ref.系统_读取or设置屏幕亮度(屏幕设备id, 亮度值).await?) 
            }
            _=>{ return Ok((false, json!(""), 参数数组)); }
        };
        Ok((true, 结果, Vec::new()))
    }

    fn 系统_读取磁盘数组(&self)-> impl 信令任务<Vec<磁盘文件项>>{
        core发布信令任务!(self, 信令表::系统_读取磁盘数组,  信令表::系统_读取磁盘数组_回复 => 磁盘数组 )
    }
    fn 系统_读取or设置屏幕亮度(&self,屏幕设备名:Option<String>, 亮度值:Option<f32>)-> impl 信令任务<Vec<显示器亮度信息>>{
        core发布信令任务!(self, 信令表::系统_读取or设置屏幕亮度{ 屏幕设备id: 屏幕设备名, 亮度值 },  信令表::系统_读取or设置屏幕亮度_回复 => 屏幕信息数组 )
    }
    
    #[cfg(all(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
    fn 系统_读取or设置壁纸(&self,路径:impl AsRef<str>)->impl 信令任务<String>{
        core发布信令任务!(self, 信令表::系统_读取or设置壁纸{ 路径:路径.as_ref().to_string() },  信令表::系统_读取or设置壁纸_回复 => 路径 )
    }

    fn 系统_读取系统OS信息(&self)-> impl 信令任务<系统OS信息>{
        core发布信令任务!(self, 信令表::系统_读取OS信息,  信令表::系统_读取OS信息_回复 => OS信息 )
    }
    fn 系统_读取CPU数组(&self)-> impl 信令任务<Vec<CPU信息>>{
        core发布信令任务!(self, 信令表::系统_读取CPU数组,  信令表::系统_读取CPU数组_回复 => CPU数组 )
    }
    fn 系统_读取网络NET数组(&self)-> impl 信令任务<Vec<NET信息>>{
        core发布信令任务!(self, 信令表::系统_读取网络NET数组,  信令表::系统_读取网络NET数组_回复 => NET数组 )
    }
    fn 系统_读取进程数组(&self)-> impl 信令任务<Vec<进程信息>>{
        core发布信令任务!(self, 信令表::系统_读取进程数组,  信令表::系统_读取进程数组_回复 => 进程数组 )
    }
    fn 系统_读取内存数组(&self)-> impl 信令任务<Vec<内存信息>>{
        core发布信令任务!(self, 信令表::系统_读取内存数组,  信令表::系统_读取内存数组_回复 => 内存数组 )
    }

    fn 系统_主动关机(&self)-> anyhow_Result<()>{
        match std::env::consts::OS {
            "windows" => { std::process::Command::new("shutdown").args(["/s", "/t", "0"]).spawn()?; }
            "linux" => { std::process::Command::new("shutdown").args(["-h", "now"]).spawn()?; }
            "macos" => { std::process::Command::new("sudo").args(["shutdown", "-h", "now"]).spawn()?; }
            _ => { return Err(anyhow_err!("系统_主动关机 错误: 未识别系统")); }
        }
        Ok(())
    }

    fn 系统_基础目录(&self)-> impl 信令任务<系统基础目录>{
        core发布信令任务!(self, 信令表::系统_读取基础目录 ,  信令表::系统_读取基础目录_回复 => 基础目录 )
    }
}



#[derive(Clone, Serialize, Deserialize)]//可选特征
enum 信令表{
    系统_读取OS信息,
    系统_读取OS信息_回复{ OS信息:系统OS信息 },
    系统_读取CPU数组,
    系统_读取CPU数组_回复{ CPU数组:Vec<CPU信息> },
    系统_读取内存数组,
    系统_读取内存数组_回复{ 内存数组:Vec<内存信息> },
    系统_读取网络NET数组,
    系统_读取网络NET数组_回复{ NET数组:Vec<NET信息> },
    系统_读取进程数组,
    系统_读取进程数组_回复{ 进程数组:Vec<进程信息> },
    系统_读取磁盘数组,
    系统_读取磁盘数组_回复{ 磁盘数组: Vec<磁盘文件项>  },

    系统_读取基础目录,
    系统_读取基础目录_回复{ 基础目录:系统基础目录 },

    系统_读取or设置屏幕亮度{ 屏幕设备id:Option<String>, 亮度值:Option<f32> },
    系统_读取or设置屏幕亮度_回复{ 屏幕信息数组:Vec<显示器亮度信息>  },

    系统_读取or设置壁纸{ 路径:String },
    系统_读取or设置壁纸_回复{ 路径:String },
}
impl信令特征!(信令表, 执行函数);


async fn 执行函数(信令路由:信令路由,id:信令ID,单个信令:信令表)->anyhow_Result<信令表>{
    match 单个信令{
        信令表::系统_读取OS信息=>{
            let 信息 = 系统OS信息{
                系统名:System::name().unwrap_or("未知".to_string()),
                主机名:System::host_name().unwrap_or("未知".to_string()),
                内核版本:System::kernel_version().unwrap_or("未知".to_string()),
                系统版本:System::long_os_version().unwrap_or("未知".to_string()),
                分发id:System::distribution_id(),
                CPU架构:System::cpu_arch(),
                时间戳: TIME时间::now_毫秒(),
            };
            anyhow_Ok信令!(信令表::系统_读取OS信息_回复 { OS信息:信息 })
        }
        信令表::系统_读取磁盘数组=>{
            let res =  信令路由.pool同步任务(move ||{  读取磁盘数组() }).await??;
            anyhow_Ok信令!(信令表::系统_读取磁盘数组_回复 { 磁盘数组:res })
        }
        信令表::系统_读取CPU数组=>{
            let res = 信令路由.pool同步任务(move||{  读取CPU信息数组() }).await?;
            anyhow_Ok信令!(信令表::系统_读取CPU数组_回复 { CPU数组:res })
        }
        信令表::系统_读取网络NET数组=>{
            let res = 信令路由.pool同步任务(move||{  读取网络NET数组() }).await??;
            anyhow_Ok信令!(信令表::系统_读取网络NET数组_回复 { NET数组:res })
        }
        信令表::系统_读取进程数组=>{
            let res = 信令路由.pool同步任务(move||{  读取进程信息数组() }).await?;
            anyhow_Ok信令!(信令表::系统_读取进程数组_回复 {  进程数组:res })
        }
        信令表::系统_读取内存数组=>{
            let res = 信令路由.pool同步任务(move||{  读取MEM内存信息() }).await?;
            anyhow_Ok信令!(信令表::系统_读取内存数组_回复 {  内存数组:res })
        }
        信令表::系统_读取基础目录=>{
            let res = 信令路由.pool同步任务(move||{  读取系统基础目录() }).await?;
            anyhow_Ok信令!(信令表::系统_读取基础目录_回复 {  基础目录:res })
        }

        信令表::系统_读取or设置屏幕亮度{ 屏幕设备id, 亮度值 }=>{
            let res = 信令路由.pool同步任务(move||{  读取or设置屏幕亮度(屏幕设备id, 亮度值)  }).await??;
            anyhow_Ok信令!(信令表::系统_读取or设置屏幕亮度_回复 {  屏幕信息数组:res })
        }
        
        #[cfg(all(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
        信令表::系统_读取or设置壁纸{ 路径 }=>{      //  a  系统_读取or设置壁纸  /home/lwl/Desktop/🌷pic/1.png
            let 结果 = if 路径 == ""{
                    wallpaper::get()
                        .map(|壁纸路径| 信令表::系统_读取or设置壁纸_回复 { 路径:壁纸路径  } )
                        .map_err(|err|anyhow_err!("{err}"))
                }else{
                    wallpaper::set_from_path(&路径)
                        .map(|_| { wallpaper::set_mode(wallpaper::Mode::Crop).ok(); 信令表::系统_读取or设置壁纸_回复 { 路径 }  })
                        .map_err(|err|anyhow_err!("{err}"))
                };
            
            anyhow_Ok信令!(结果?)
        }
        _ =>{ return Err(anyhow_err!("信令不存在")); }
    }
}


#[cfg(all(test,feature = "mod_os"))]
mod  测试{
    use crate::prelude::*;
    use super::*;
    #[cfg(all(test,feature = "mod_os"))]
    #[test]
    fn 测试1(){
        // 🔥🔥🔥 js child_process.spawn 调用二进制，必须带有  process.env  ，否则报错🔥🔥🔥
        let 信令路由 =  信令路由::default();   //  gio_磁盘查询数组
        信令路由.clone().pool异步任务_block阻塞完成(async move{
            let out = 信令路由.系统_读取网络NET数组().await.unwrap();
            eprintln!("\n🌷结果🌷>>\n{:?}",json!(out) );
        }).ok();
    }


}




pub fn 读取磁盘数组() -> anyhow_Result<Vec<磁盘文件项>> {
    let mut disks = 全局_DISKS.lock();
    disks.refresh(true);
    // let 文件名正则 = Regex::new(r"[^\/]+$|[\/]$")?;
    let mut 结果数组: Vec<磁盘文件项> = Vec::new();
    for disk in disks.list() {
        let mut 磁盘项 = 磁盘文件项::default();
        磁盘项.设备 = disk.name().to_str().unwrap_or_default().to_string();
        磁盘项.磁盘类型 = disk.kind().to_string();
        磁盘项.磁盘格式 = disk.file_system().to_str().unwrap_or_default().to_string();
        磁盘项.挂载路径 = disk.mount_point().to_str().unwrap_or_default().to_string();
        磁盘项.路径 = 磁盘项.挂载路径.clone();
        磁盘项.uri路径 = format!("file://{}",&磁盘项.路径);
        // let 显示文件名 = 文件名正则.find(&磁盘项.挂载路径); 
        // 磁盘项.显示文件名 = match 显示文件名 {
        //     Some(文件名)=> 文件名.as_str().to_string(),
        //     None=> "".to_string()
        // };
        磁盘项.显示文件名 = std::path::PathBuf::from(&磁盘项.挂载路径).file_name().unwrap_or_default().display().to_string();
        磁盘项.容量size = disk.total_space();
        磁盘项.可用size = disk.available_space();
        磁盘项.已用size = 磁盘项.容量size - 磁盘项.可用size;
        磁盘项.容量 = 信令路由::fn_字节to可读(磁盘项.容量size);
        磁盘项.可用 = 信令路由::fn_字节to可读(磁盘项.可用size);
        磁盘项.已用 = 信令路由::fn_字节to可读(磁盘项.已用size);
        磁盘项.已用百分比 = (磁盘项.已用size as f64/磁盘项.容量size as f64 * 100. ).round() as u64; 
        结果数组.push(磁盘项);
    }
    Ok(结果数组)
}


pub fn 读取CPU信息数组()->Vec<CPU信息>{
    let mut sys = 全局_SYSTEM.lock();
    sys.refresh_cpu_all();
    let mut 结果数组 = Vec::new();
    for cpu in sys.cpus() {
        结果数组.push(CPU信息{
            CPU名称:cpu.name().to_string(),
            CPU频率:cpu.frequency(),
            CPU使用率:cpu.cpu_usage(),
            CPU型号:cpu.brand().to_string(),
            CPU销售商代码:cpu.vendor_id().to_string(),
            CPU物理核心数:System::physical_core_count().unwrap_or_default(),
            时间戳:TIME时间::now_毫秒(),
        });
    }
    结果数组
}
pub fn 读取MEM内存信息()->Vec<内存信息>{
    let mut sys = 全局_SYSTEM.lock();
    sys.refresh_memory();
    let mut 内存数组 = Vec::new();
    内存数组.push(内存信息{
        名称:"物理内存".to_string(),
        占用:sys.used_memory(),
        空闲:sys.free_memory(),
        总量:sys.total_memory(),
        时间戳:TIME时间::now_毫秒(),
    });
    内存数组.push(内存信息{
        名称:"swap内存".to_string(),
        占用:sys.used_swap(),
        空闲:sys.free_swap(),
        总量:sys.total_swap(), 
        时间戳:TIME时间::now_毫秒(),
    });
    内存数组
}
pub fn 读取网络NET数组()->anyhow_Result<Vec<NET信息>>{
    let interfaces = NetworkInterface::show()?;
    let 查找ip数组 = |mac:String|->Vec<IpAddr>{
        let mut 最终数组 = Vec::new();
        interfaces.iter()
            .for_each(|inter|{
                let mac_addr = inter.mac_addr.clone().unwrap_or_default();
                if mac == mac_addr {
                    inter.addr.iter().for_each(|addr|{
                        match addr {
                            Addr::V4(ip4)=>{ 最终数组.push(IpAddr::V4(ip4.ip.clone()));  }
                            Addr::V6(ip6)=>{ 最终数组.push(IpAddr::V6(ip6.ip.clone()));  }
                        }
                    });
                }
            });
        最终数组
    };

    let mut net = 全局_NETWORKS.lock();
    net.refresh(true);
    let mut 结果数组 = Vec::new();
    for (name, data) in net.list() {
        结果数组.push(NET信息{
            接口名:name.to_string(),
            接收字节:data.received(),
            接收字节总量:data.total_received(),
            发送字节:data.transmitted(),
            发送字节总量:data.total_transmitted(),
            接收包数:data.packets_received(),
            接收包数总量:data.total_packets_received(),
            发送包数:data.packets_transmitted(),
            发送包数总量:data.total_packets_transmitted(),
            接收错误包数:data.errors_on_received(),
            接收错误包数总量:data.total_errors_on_received(),
            发送错误包数:data.errors_on_transmitted(),
            发送错误包数总量:data.total_errors_on_received(),
            mac地址:data.mac_address().to_string(),
            ip地址数组:查找ip数组(data.mac_address().to_string()),
            时间戳:TIME时间::now_毫秒(),
        });
    }
    
    Ok(结果数组)
}
pub fn 读取进程信息数组()->Vec<进程信息>{
    let mut sys = 全局_SYSTEM.lock();
    sys.refresh_processes(sysinfo::ProcessesToUpdate::All, true);
    let mut 结果数组 = Vec::new();
    for (pid, process) in sys.processes() {
        结果数组.push(进程信息{
            pid:pid.to_string().parse::<isize>().unwrap_or_default(),
            ppid:process.parent().map(|pid|pid.to_string().parse::<isize>().unwrap_or_default()).unwrap_or_default(),
            名称:process.name().display().to_string(),
            cmd指令:process.cmd().to_owned().iter().map(|cmd|cmd.display().to_string()).collect::<Vec<_>>(),
            cwd工作目录:process.cwd().map(|path|path.display().to_string()).unwrap_or_default(),
            环境变量:process.environ().to_owned().iter().map(|cmd|cmd.display().to_string()).collect::<Vec<_>>(),
            exe路径:process.exe().map(|path|path.display().to_string()).unwrap_or_default(),
            cpu占用率:process.cpu_usage(),
            内存占用:process.memory(),
            时间戳:TIME时间::now_毫秒(),
        });
    }
    结果数组
}


pub fn 读取or设置屏幕亮度(屏幕设备id:Option<String>, 亮度值:Option<f32>)->anyhow_Result<Vec<显示器亮度信息>>{
    if let Some(设备id) = 屏幕设备id{
        let 亮度 = 亮度值.ok_or(anyhow_err!("设置屏幕亮度 传入值不能为空！！！"))?;
        let status = std::process::Command::new("xrandr")
            .arg("--output")
            .arg(&设备id)
            .arg("--brightness")
            .arg(亮度.to_string())
            .status()?;
        
        if ! status.success() { 
            return Err(anyhow_err!("{设备id} 设置亮度 {亮度} 失败!!!"));
        }
    }

    //---- 查询后输出 -------
    let output = std::process::Command::new("xrandr")
        .arg("--verbose")
        .output()?;
    
    let output_str = String::from_utf8_lossy(&output.stdout);
    
    let mut 显示器数组 = Vec::new(); 
    for 匹配 in Regex::new(r"[\n\r][^\n\r]+ connected[\w\W]+?range:").unwrap().find_iter(&output_str){
        let 文本 = 匹配.as_str();
        let mut 亮度信息 = 显示器亮度信息::default();
        // 查找主显示器
        for line in 文本.lines() {
            if line.contains(" connected primary") {
                亮度信息.名称 = line.split_whitespace().next().unwrap_or("").to_string();
            }
            else if line.contains("Identifier:") {
                let mut 迭代器 = line.split_whitespace();
                let _ = 迭代器.next();
                亮度信息.id = 迭代器.next().unwrap_or("").to_string();
            }
            else if line.contains("Brightness:") {
                let mut 迭代器 = line.split_whitespace();
                let _ = 迭代器.next();
                亮度信息.亮度 = 迭代器.next().unwrap_or("").parse::<f32>().unwrap_or_default();
            }
            if 亮度信息.亮度 != 0.0f32{ break; }
        }
        显示器数组.push(亮度信息);
    }
    
    Ok(显示器数组)
}







#[derive(Debug, Serialize, Deserialize,Clone,Default)]
pub struct 系统基础目录{
    pub cache:String,
    pub config:String,
    pub config_local:String,
    pub data:String,
    pub data_local:String,
    pub document:String,
    pub download:String,
    pub picture:String,
    pub public:String,
    pub video:String,
    pub audio:String,
    pub temp:String,

    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub desktop:String,
    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub executable:String,
    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub font:String,
    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub home:String,
    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub runtime:String,
    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub template:String,
    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub preference:String,
    #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
    pub state:String,
}
pub fn 读取系统基础目录()-> 系统基础目录{
    系统基础目录{
        cache:dirs::cache_dir().unwrap_or_default().display().to_string(),
        config:dirs::config_dir().unwrap_or_default().display().to_string(),
        config_local:dirs::config_local_dir().unwrap_or_default().display().to_string(),
        data:dirs::data_dir().unwrap_or_default().display().to_string(),
        data_local:dirs::data_local_dir().unwrap_or_default().display().to_string(),
        
        document:dirs::document_dir().unwrap_or_default().display().to_string(),
        download:dirs::download_dir().unwrap_or_default().display().to_string(),
        picture:dirs::picture_dir().unwrap_or_default().display().to_string(),
        public:dirs::public_dir().unwrap_or_default().display().to_string(),
        video:dirs::video_dir().unwrap_or_default().display().to_string(),
        audio:dirs::audio_dir().unwrap_or_default().display().to_string(),
        temp:std::env::temp_dir().display().to_string(),

        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        desktop:dirs::desktop_dir().unwrap_or_default().display().to_string(),
        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        executable:dirs::executable_dir().unwrap_or_default().display().to_string(),
        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        font:dirs::font_dir().unwrap_or_default().display().to_string(),
        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        home:dirs::home_dir().unwrap_or_default().display().to_string(),
        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        runtime:dirs::runtime_dir().unwrap_or_default().display().to_string(),
        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        template:dirs::template_dir().unwrap_or_default().display().to_string(),
        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        preference:dirs::preference_dir().unwrap_or_default().display().to_string(),
        #[cfg(any(target_os = "macos", target_os = "linux", target_os = "windows"))]
        state:dirs::state_dir().unwrap_or_default().display().to_string(),
    }
}









/*
   @常用
   Arc<>           可以多线程共享,但只读
   Arc<Mutex<>>    可以多线程共享,可读写

   Box<>           可以存放相同特征, 但是不同实体的函数/数据
   
   Option<>        可以被  .ok_or(err)?  转化为 Result<>
   Result<A>       可以被  .map(|结果|{})  .map_err(|err|{})  重新包装为   Result<B>
    

// use std::os::unix::net::{ UnixListener, UnixStream, UnixDatagram }; 
// let (sock1, sock2) = UnixDatagram::pair().expect("错误,无法创建sock1");
        {
            let mut temp = self.终端工作状态.lock();
            let count = temp.entry(term_id.0).or_insert(0);
            *count += 1;
        }

*/







//================ os ================

#[derive(Debug, Serialize, Deserialize,Clone,Default)]
pub struct 显示器亮度信息{
    pub id:String,
    pub 名称:String,
    pub 亮度:f32,
}

#[derive(Debug, Serialize, Deserialize,Clone,Default)]
pub struct 系统OS信息{
    pub 系统名:String,
    pub 主机名:String,
    pub 内核版本:String,
    pub 系统版本:String,
    pub 分发id:String,
    pub CPU架构:String,
    pub 时间戳:u128,
}



#[derive(Debug,Serialize, Deserialize,Clone,Default)]
pub struct 磁盘文件项{
    pub 显示文件名:String,
    pub 设备: String,
    pub 磁盘类型:String,
    pub 磁盘格式:String,
    pub 挂载路径:String,
    pub uri路径:String,
    pub 路径:String,
    pub 容量:String,
    pub 可用:String,
    pub 已用:String,
    pub 容量size:u64,
    pub 可用size:u64,
    pub 已用size:u64,
    pub 已用百分比:u64,
}





#[derive(Debug, Serialize, Deserialize,Clone,Default)]
pub struct CPU信息{
    pub CPU名称:String,
    pub CPU频率:u64,
    pub CPU使用率:f32,
    pub CPU型号:String,
    pub CPU销售商代码:String,
    pub CPU物理核心数:usize,
    pub 时间戳:u128,
}
#[derive(Debug, Serialize, Deserialize,Clone,Default)]
pub struct 内存信息{
    pub 名称:String,
    pub 占用:u64,
    pub 空闲:u64,
    pub 总量:u64,
    pub 时间戳:u128,
}

#[derive(Debug, Serialize, Deserialize,Clone,Default)]
pub struct NET信息{
    pub 接口名:String,
    pub 接收字节:u64,
    pub 接收字节总量:u64,
    pub 发送字节:u64,
    pub 发送字节总量:u64,
    pub 接收包数:u64,
    pub 接收包数总量:u64,
    pub 发送包数:u64,
    pub 发送包数总量:u64,
    pub 接收错误包数:u64,
    pub 接收错误包数总量:u64,
    pub 发送错误包数:u64,
    pub 发送错误包数总量:u64,
    pub mac地址:String,
    pub ip地址数组:Vec<IpAddr>,
    pub 时间戳:u128,
}

#[derive(Debug, Serialize, Deserialize,Clone,Default)]
pub struct 进程信息{
    pub pid:isize,
    pub ppid:isize,
    pub 名称:String,
    pub exe路径:String,
    pub cmd指令:Vec<String>,
    pub cwd工作目录:String, 
    pub 环境变量:Vec<String>,
    pub cpu占用率:f32,
    pub 内存占用:u64,
    pub 时间戳:u128,
}



/* 
use trash;
struct 回收站_trash;
impl 回收站_trash{
    fn 回收站_回收文件(路径数组:Vec<String>)-> Result<()>{
        trash::delete_all(路径数组)?;
        Ok(())
    }
    fn 回收站_列出文件()-> Result<Vec<trash::TrashItem>>{ 
        let 数组 = trash::os_limited::list()?;
        Ok(数组)
    }
    fn 回收站_文件信息(路径数组: Vec<String>)-> Result<Vec<trash::TrashItemMetadata>>{ 
        let mut 数组 = trash::os_limited::list()?;
        if 路径数组.len() > 0 { 
            数组.retain(|x| { 路径数组.iter().any(|文件id|{ 文件id == x.id.to_str().unwrap_or_default()  } )  } );
            
        } 
        let mut 输出 = Vec::new();
        for item in 数组{
            let 信息 = trash::os_limited::metadata(&item).unwrap();
            输出.push(信息);
        }
        Ok(输出)
    }
    fn 回收站_永久删除文件(路径数组: Vec<String>) -> Result<()>{
        let mut 数组 = trash::os_limited::list()?;
        if 路径数组.len() >0 {
            数组.retain(|x| { 路径数组.iter().any(|文件id|{ 文件id == x.id.to_str().unwrap_or_default()  } )  } );
            trash::os_limited::purge_all(&数组)?;
        }else{ 
            trash::os_limited::purge_all(&数组)?;
        }
        Ok(())
    }
    fn 回收站_还原文件(路径数组: Vec<String>) -> Result<()>{
        let mut 数组 = trash::os_limited::list()?;
        数组.retain(|x| { 路径数组.iter().any(|文件id|{ 文件id == x.id.to_str().unwrap_or_default()  } )  } );
        
        if let Err(err) = std::panic::catch_unwind(|| {
            trash::os_limited::restore_all(数组.to_vec()).unwrap();
        }){
            return Err(anyhow_err!("回收站_还原文件: {:?}",err));
        }
        Ok(())
    }

}
*/