use std::process::Command;

pub mod output;

pub struct Process {
    pub command: Vec<String>,
    pub cwd: Option<String>,
    pub env: Vec<String>,
}

impl Process {
    pub fn new(command: Vec<String>, cwd: Option<String>, env: Vec<String>) -> Process {
        Process { command, cwd, env }
    }

    pub fn command<S: Into<String>>(cmd: Vec<S>) -> Process {
        Process::new(cmd.into_iter().map(|v| v.into()).collect(), None, vec![])
    }

    pub fn spawn(&self) -> std::io::Result<std::process::Child> {
        let mut child = Command::new(&self.command[0])
            .args(&self.command[1..])
            .current_dir(self.cwd.clone().unwrap_or(".".to_string()))
            .envs(self.env.iter().map(|v| {
                let mut split = v.split('=');
                (
                    split.next().unwrap().to_string(),
                    split.next().unwrap().to_string(),
                )
            }))
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped())
            .spawn()?;
        output::spawn_output_handlers(&mut child);
        Ok(child)
    }
}

impl Default for Process {
    fn default() -> Process {
        Process::new(vec![], None, vec![])
    }
}