use super::{std, help, PackageManager};
use management::Management;
use std::process::Command;
/// A struct to hold parsed arg data.
// TODO?: update to take mutltiple terms?
#[derive(Debug)]
pub struct Config {
    pub action: Management,
    pub term: Option<String>,
}

impl Config {
    /// Actually runs the package manager. Checks what command was requested
    /// and loads the appropriate data from the passed `PackageManager`.
    /// Finally calls the program and passes the appropriate arguments
    pub fn run(&self, pac: PackageManager) {
        let get = match self.action {
            Management::Search => pac.search,
            Management::Install => pac.install,
            Management::Uninstall => pac.uninstall,
            Management::Remove => pac.purge,
            Management::Update => pac.update,
            Management::Upgrade => pac.upgrade,
            Management::Full => pac.sup,
            Management::Clear => pac.cache_clear,
            Management::CompleteClear => pac.complete_cache_clear,
        };

        // takes `Option(Vec<&str>)` and returns `Vec<&str>` if `Some(_)`
        // If `None`, tell user and exit.
        let mut prog = get.unwrap_or_else(|| {
            println!("Sorry, your package manager does not support this action");
            std::process::exit(0)
        });

        //Pop's from the front of the `Vec<&str>`, which should always be the command name
        let command = prog.remove(0);

        // Tuple match, `prog.first()` returns an `Option<T>` on the first element of
        // a Vec, `self.term` is also an `Option<T>` so this checks both for `Some`/`None`
        // and formats the program call as needed
        match (prog.first(), &self.term) {
            (None, &None) => {
                let mut child = Command::new(&command).spawn().expect(
                    "Failed to open package manager",
                );
                child.wait().expect("Failed to wait on package manager");
            }
            (None, &Some(ref term)) => {
                let mut child = Command::new(&command).arg(term).spawn().expect(
                    "Failed to open package manager",
                );
                child.wait().expect("Failed to wait on package manager");
            }
            (Some(_), &None) => {
                for arg in &prog {
                    let mut child = Command::new(&command).arg(arg).spawn().expect(
                        "Failed to open package manager",
                    );
                    child.wait().expect("Failed to wait on child");
                }
            }
            (Some(_), &Some(ref term)) => {
                for arg in &prog {
                    let mut child = Command::new(&command).arg(arg).arg(term).spawn().expect(
                        "Failed to open package manager",
                    );
                    child.wait().expect("Failed to wait on child");
                }
            }
        }
    }
    /// Creates a `Config` from passed arguments, parses the `Management` enum
    /// and term (if any). Requires an action, while the term can be `None`.
    pub fn new() -> Config {
        let action = match Management::parse(std::env::args().nth(1)) {
            None => {
                println!("No command actions passed");
                help();
                std::process::exit(0)
            }
            Some(command) => command,
        };
        let term = std::env::args().nth(2);

        Config {
            action: action,
            term: term,
        }
    }
}