use std::fs;
use std::process::{Stdio, Command};
use tokio::process::Command as AsyncCommand;
use tokio::process::Child as AsyncChild;

pub fn get_all_pids() -> Vec<i32> {
    let mut pids = Vec::<i32>::new();
    let files = fs::read_dir("/proc/").unwrap();

    for entry in files {
        let path = entry.unwrap().path();
        if path.is_dir() {
            if let Some(name) = path.file_name() {
                let name = name.to_str().unwrap();
                match name.parse::<i32>() {
                    Ok(pid) => {
                        if pid > 1 {
                            let content = fs::read_to_string(format!("/proc/{}/cmdline", pid));
                            match content {
                                Ok(cmdline) => {
                                    //if cmdline != "" {
                                    pids.push(pid);
                                    //}
                                },
                                Err(_) => {}
                            }
                        }
                    },

                    Err(_) => {}
                }
            }
        }
    }

    pids
}

pub fn sync_run_wait(path: &str, args: &[&str]) {
    let mut child = Command::new(path)
                            .env("PATH", "/sbin:/bin:/usr/bin")
                            .args(args)
                            .spawn()
                            .unwrap();
    
    child.wait().unwrap();
    ()
}


pub async fn run(path: &str, args: &[&str]) -> AsyncChild {
    AsyncCommand::new(path)
            .env("PATH", "/sbin:/bin:/usr/bin")
            .args(args)
            .stdout(Stdio::null())
            .spawn()
            .unwrap()
}

pub async fn run_wait(path: &str, args: &[&str]) {
    let child = AsyncCommand::new(path)
                        .env("PATH", "/sbin:/bin:/usr/bin")
                        .args(args)
                        .spawn()
                        .unwrap();

    child.await.unwrap();
    ()
}